cottus 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ecc4ff9c7665bc9c8dd0bfd2f823b75cad6274e2
-  data.tar.gz: 0689ac0d84036f71550017bde201bb533215a8fb
+  metadata.gz: 362f67d0f8c8fd3245548533ae68bbcf1e012957
+  data.tar.gz: be8e86a230fac1d891506d1616a84745b3c6f7d4
 SHA512:
-  metadata.gz: e297a556782028c264222df3e6a3edaf657ddc9e4eaa243f238fae2188eb512e6635827edadf05a31f24350f8b4cf5ccecaa3880cc9acfcb7c5e357dafdb2b5b
-  data.tar.gz: bd848b6c1b94e89a97e16bf701086251bdf5cfe65af1c0a75d03782ab271ad9792134dda673186e061b45da9adc18356a18c5a2d4907db16de11149cbec21915
+  metadata.gz: 5c7139181bc75a318f1ad87e5989c7d8c76d67fa44ed512a628aad0be3a3c227bd5a4bb745a7879b2b980a52170a5528f0c43e7b89217cb8ecf5454a1a7b3c93
+  data.tar.gz: dda18ac01482b6d1885517dbfd231d637e590e1c930ef42409d66faefd5e1b7a9a6f2daeb7bf0184d3df9316cf3686ae3ce1758948695916aef0c2268d626e1e

data/README.md

@@ -46,11 +46,11 @@ responsible for carrying out the action specified by the passed ```meth```
 argument.
 
 The Strategy class must however also implement an ```#initialize``` method which
-takes three parameters: ```hosts```, ```client``` and an ```options``` hash:
+takes two parameters: ```connections``` and an ```options``` hash:
 
 ```ruby
 class SomeStrategy
-  def initialize(hosts, client, options={})
+  def initialize(connections, options={})
   end
 
   def execute(meth, path, options={}, &block)
@@ -72,7 +72,7 @@ end
 
 If you'd like to do some initialization on your own and override
 ```#initialize``` make sure to call ```#super``` or set the required instance
-variables (```@hosts```, ```@client```) on your own.
+variable (```@connections```) on your own.
 
 It should be noted that I haven't decided on how strategies should be working to
 a 100% yet, so this might change in future releases.

data/lib/cottus/client.rb

@@ -2,60 +2,36 @@
 
 module Cottus
   class Client
+    extend Forward
 
-    attr_reader :hosts, :strategy
+    forward :get, :put, :post, :delete, :head, :patch, :options, :move, :to => :@strategy, :through => :execute
+
+    attr_reader :connections, :strategy
 
     def initialize(hosts, options={})
-      @hosts = parse_hosts(hosts)
+      @connections = create_connections(hosts)
       @strategy = create_strategy(options)
     end
 
-    def get(path, options={}, &block)
-      @strategy.execute(:get, path, options, &block)
-    end
-
-    def put(path, options={}, &block)
-      @strategy.execute(:put, path, options, &block)
-    end
-
-    def post(path, options={}, &block)
-      @strategy.execute(:post, path, options, &block)
-    end
-
-    def delete(path, options={}, &block)
-      @strategy.execute(:delete, path, options, &block)
-    end
-
-    def head(path, options={}, &block)
-      @strategy.execute(:head, path, options, &block)
-    end
-
-    def patch(path, options={}, &block)
-      @strategy.execute(:patch, path, options, &block)
-    end
-
-    def options(path, options={}, &block)
-      @strategy.execute(:options, path, options, &block)
-    end
-
-    def move(path, options={}, &block)
-      @strategy.execute(:move, path, options, &block)
+    def hosts
+      @connections.map(&:host)
     end
 
     private
 
-    def parse_hosts(hosts)
-      hosts.is_a?(String) ? hosts.split(',') : hosts
-    end
-
-    def http
-      HTTParty
+    def create_connections(hosts)
+      hosts = hosts.is_a?(String) ? hosts.split(',') : hosts
+      hosts.map { |host| Connection.new(http, host) }
     end
 
     def create_strategy(options)
       strategy_options = options[:strategy_options] || {}
       strategy_impl = options[:strategy] || RoundRobinStrategy
-      strategy_impl.new(hosts, http, strategy_options)
+      strategy_impl.new(connections, strategy_options)
+    end
+
+    def http
+      HTTParty
     end
   end
 end

data/lib/cottus/connection.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cottus
+  class Connection
+    extend Forward
+
+    forward :get, :put, :post, :delete, :head, :patch, :options, :move, :to => :wrapper
+
+    attr_reader :host
+
+    def initialize(*args)
+      @http, @host = *args
+    end
+
+    private
+
+    def wrapper(verb, path, options={}, &blk)
+      @http.send(verb, @host + path, options, &blk)
+    end
+  end
+end

data/lib/cottus/forward.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Cottus
+  module Forward
+    def forward(*args)
+      options = args.pop
+      to, through = options.values_at(:to, :through)
+
+      args.each do |verb|
+        define_method(verb) do |path, opts={}, &blk|
+          if to && through
+            instance_variable_get(to).send(through, verb, path, opts, &blk)
+          else
+            self.send(to, verb, path, opts, &blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cottus/strategies.rb

@@ -10,8 +10,8 @@ module Cottus
   ].freeze
 
   class Strategy
-    def initialize(hosts, client, options={})
-      @hosts, @client = hosts, client
+    def initialize(connections, options={})
+      @connections = connections
     end
 
     def execute(meth, path, options={}, &block)
@@ -20,10 +20,10 @@ module Cottus
   end
 
   class RoundRobinStrategy < Strategy
-    def initialize(hosts, client, options={})
+    def initialize(connections, options={})
       super
 
-      @current = 0
+      @index = 0
       @mutex = Mutex.new
     end
 
@@ -31,9 +31,9 @@ module Cottus
       tries = 0
 
       begin
-        @client.send(meth, next_host + path, options, &block)
+        next_connection.send(meth, path, options, &block)
       rescue *VALID_EXCEPTIONS => e
-        if tries >= @hosts.count
+        if tries >= @connections.count
           raise e
         else
           tries += 1
@@ -44,17 +44,17 @@ module Cottus
 
     private
 
-    def next_host
+    def next_connection
       @mutex.synchronize do
-        h = @hosts[@current]
-        @current = (@current + 1) % @hosts.count
-        h
+        connection = @connections[@index]
+        @index = (@index + 1) % @connections.count
+        connection
       end
     end
   end
 
   class RetryableRoundRobinStrategy < RoundRobinStrategy
-    def initialize(hosts, client, options={})
+    def initialize(connections, options={})
       super
 
       @timeouts = options[:timeouts] || [1, 3, 5]
@@ -62,18 +62,18 @@ module Cottus
 
     def execute(meth, path, options={}, &block)
       tries = 0
-      starting_host = host = next_host
+      starting_connection = connection = next_connection
 
       begin
-        @client.send(meth, host + path, options, &block)
+        connection.send(meth, path, options, &block)
       rescue *VALID_EXCEPTIONS => e
         if tries < @timeouts.size
           sleep @timeouts[tries]
           tries += 1
           retry
         else
-          host = next_host
-          raise e if host == starting_host
+          connection = next_connection
+          raise e if connection == starting_connection
 
           tries = 0
           retry

data/lib/cottus/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cottus
-  VERSION = '0.1.4'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/cottus.rb

@@ -2,5 +2,7 @@
 
 require 'httparty'
 
+require 'cottus/forward'
 require 'cottus/client'
 require 'cottus/strategies'
+require 'cottus/connection'

data/spec/cottus/client_spec.rb

@@ -47,7 +47,7 @@ module Cottus
         context 'strategy options' do
           it 'passes explicit options when creating strategy' do
             client = described_class.new('http://localhost:1234', strategy: strategy, strategy_options: {timeouts: [1, 3, 5]})
-            expect(strategy).to have_received(:new).with(anything, anything, {timeouts: [1, 3, 5]})
+            expect(strategy).to have_received(:new).with(anything, {timeouts: [1, 3, 5]})
           end
         end
       end

data/spec/cottus/strategies_spec.rb

@@ -5,16 +5,24 @@ require 'spec_helper'
 module Cottus
   describe Strategy do
     let :strategy do
-      described_class.new(['http://n1.com', 'http://n2.com'], http)
+      described_class.new(connections)
     end
 
     let :http do
-      double(:http, meth: nil)
+      double(:http, get: nil)
+    end
+
+    let :hosts do
+      ['http://n1.com', 'http://n2.com']
+    end
+
+    let :connections do
+      hosts.map { |host| Connection.new(http, host) }
     end
 
     describe '#execute' do
       it 'raises a NotImplementedError' do
-        expect { strategy.execute(:meth, '/some/path') }.to raise_error(NotImplementedError, 'implement me in subclass')
+        expect { strategy.execute(:get, '/some/path') }.to raise_error(NotImplementedError, 'implement me in subclass')
       end
     end
   end
@@ -26,15 +34,15 @@ module Cottus
       end
 
       it 'uses the single host for the first request' do
-        strategy.execute(:meth, '/some/path', query: { query: 1 })
+        strategy.execute(:get, '/some/path', query: { query: 1 })
 
-        expect(http).to have_received(:meth).with('n1/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).once
       end
 
       it 'uses the single host for the second request' do
-        2.times { strategy.execute(:meth, '/some/path', query: { query: 1 }) }
+        2.times { strategy.execute(:get, '/some/path', query: { query: 1 }) }
 
-        expect(http).to have_received(:meth).with('n1/some/path', query: { query: 1 }).twice
+        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).twice
       end
     end
 
@@ -44,35 +52,39 @@ module Cottus
       end
 
       it 'uses the first host for the first request' do
-        strategy.execute(:meth, '/some/path', query: { query: 1 })
+        strategy.execute(:get, '/some/path', query: { query: 1 })
 
-        expect(http).to have_received(:meth).with('n1/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).once
       end
 
       it 'uses the second host for the second request' do
-        2.times { strategy.execute(:meth, '/some/path', query: { query: 1 }) }
+        2.times { strategy.execute(:get, '/some/path', query: { query: 1 }) }
 
-        expect(http).to have_received(:meth).with('n1/some/path', query: { query: 1 }).once
-        expect(http).to have_received(:meth).with('n2/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n2/some/path', query: { query: 1 }).once
       end
 
       it 'uses each host in turn' do
-        3.times { strategy.execute(:meth, '/some/path', query: { query: 1 }) }
+        3.times { strategy.execute(:get, '/some/path', query: { query: 1 }) }
 
-        expect(http).to have_received(:meth).with('n1/some/path', query: { query: 1 }).once
-        expect(http).to have_received(:meth).with('n2/some/path', query: { query: 1 }).once
-        expect(http).to have_received(:meth).with('n3/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n2/some/path', query: { query: 1 }).once
+        expect(http).to have_received(:get).with('n3/some/path', query: { query: 1 }).once
       end
     end
   end
 
   describe RoundRobinStrategy do
     let :strategy do
-      described_class.new(hosts, http)
+      described_class.new(connections)
     end
 
     let :http do
-      double(:http, meth: nil)
+      double(:http, get: nil)
+    end
+
+    let :connections do
+      hosts.map { |host| Connection.new(http, host) }
     end
 
     describe '#execute' do
@@ -89,9 +101,9 @@ module Cottus
               end
 
               it 'gives up' do
-                hosts.each { |h| http.stub(:meth).with("#{h}/some/path", {}).and_raise(error) }
+                hosts.each { |h| http.stub(:get).with("#{h}/some/path", {}).and_raise(error) }
 
-                expect { strategy.execute(:meth, '/some/path') }.to raise_error(error)
+                expect { strategy.execute(:get, '/some/path') }.to raise_error(error)
               end
             end
 
@@ -101,16 +113,16 @@ module Cottus
               end
 
               it 'attempts to use each host until one succeeds' do
-                ['n1', 'n2'].each { |h| http.stub(:meth).with("#{h}/some/path", {}).and_raise(error) }
+                ['n1', 'n2'].each { |h| http.stub(:get).with("#{h}/some/path", {}).and_raise(error) }
 
-                strategy.execute(:meth, '/some/path')
-                expect(http).to have_received(:meth).with('n3/some/path', {})
+                strategy.execute(:get, '/some/path')
+                expect(http).to have_received(:get).with('n3/some/path', {})
               end
 
               it 'gives up after trying all hosts' do
-                hosts.each { |h| http.stub(:meth).with("#{h}/some/path", {}).and_raise(error) }
+                hosts.each { |h| http.stub(:get).with("#{h}/some/path", {}).and_raise(error) }
 
-                expect { strategy.execute(:meth, '/some/path') }.to raise_error(error)
+                expect { strategy.execute(:get, '/some/path') }.to raise_error(error)
               end
             end
           end
@@ -121,11 +133,15 @@ module Cottus
 
   describe RetryableRoundRobinStrategy do
     let :strategy do
-      described_class.new(hosts, http, timeouts: [0, 0, 0])
+      described_class.new(connections, timeouts: [0, 0, 0])
     end
 
     let :http do
-      double(:http, meth: nil)
+      double(:http, get: nil)
+    end
+
+    let :connections do
+      hosts.map { |host| Connection.new(http, host) }
     end
 
     describe '#execute' do
@@ -142,18 +158,18 @@ module Cottus
               end
 
               it 'uses the single host for three consecutive exceptions' do
-                expect(http).to receive(:meth).with('n1/some/path', {}).exactly(3).times.and_raise(error)
-                expect(http).to receive(:meth).with('n1/some/path', {}).once
+                expect(http).to receive(:get).with('n1/some/path', {}).exactly(3).times.and_raise(error)
+                expect(http).to receive(:get).with('n1/some/path', {}).once
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
-                strategy.execute(:meth, '/some/path')
+                strategy.execute(:get, '/some/path')
               end
 
               it 'gives up after three retries' do
-                expect(http).to receive(:meth).with('n1/some/path', {}).exactly(4).times.and_raise(error)
+                expect(http).to receive(:get).with('n1/some/path', {}).exactly(4).times.and_raise(error)
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
-                expect { strategy.execute(:meth, '/some/path') }.to raise_error(error)
+                expect { strategy.execute(:get, '/some/path') }.to raise_error(error)
               end
             end
 
@@ -163,19 +179,19 @@ module Cottus
               end
 
               it 'uses the same host for three consecutive exceptions' do
-                expect(http).to receive(:meth).with('n1/some/path', {}).exactly(3).times.and_raise(error)
-                expect(http).to receive(:meth).with('n1/some/path', {}).once
+                expect(http).to receive(:get).with('n1/some/path', {}).exactly(3).times.and_raise(error)
+                expect(http).to receive(:get).with('n1/some/path', {}).once
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
-                strategy.execute(:meth, '/some/path')
+                strategy.execute(:get, '/some/path')
               end
 
               it 'switches host after three retries' do
-                expect(http).to receive(:meth).with('n1/some/path', {}).exactly(4).times.and_raise(error)
-                expect(http).to receive(:meth).with('n2/some/path', {}).once
+                expect(http).to receive(:get).with('n1/some/path', {}).exactly(4).times.and_raise(error)
+                expect(http).to receive(:get).with('n2/some/path', {}).once
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
-                strategy.execute(:meth, '/some/path')
+                strategy.execute(:get, '/some/path')
               end
             end
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cottus
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Mathias Söderberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-25 00:00:00.000000000 Z
+date: 2013-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -32,6 +32,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cottus/client.rb
+- lib/cottus/connection.rb
+- lib/cottus/forward.rb
 - lib/cottus/strategies.rb
 - lib/cottus/version.rb
 - lib/cottus.rb