cottus 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 362f67d0f8c8fd3245548533ae68bbcf1e012957
-  data.tar.gz: be8e86a230fac1d891506d1616a84745b3c6f7d4
+  metadata.gz: b664ce094bd30b48d6e6a4f0bc136d9b78a27e0e
+  data.tar.gz: 6cedfbfa25af3845515d43ba47305ea0402d3c8c
 SHA512:
-  metadata.gz: 5c7139181bc75a318f1ad87e5989c7d8c76d67fa44ed512a628aad0be3a3c227bd5a4bb745a7879b2b980a52170a5528f0c43e7b89217cb8ecf5454a1a7b3c93
-  data.tar.gz: dda18ac01482b6d1885517dbfd231d637e590e1c930ef42409d66faefd5e1b7a9a6f2daeb7bf0184d3df9316cf3686ae3ce1758948695916aef0c2268d626e1e
+  metadata.gz: dc7a3b6eccaab7606cc74397f3c5b4a1d7c8b545938aebbec7ec0642512282b5d60c447316239668cae5e8326e40bf1e5583c36f8533d84c87186a35dbe80235
+  data.tar.gz: f80fc8cc0939e4980d43e9315e2290a3c19200abb63cbdcc9c056c26e0d0be7e4cf204cb0918dee4c8fc6a36c64d968080b4a3849528fe9d588107314cea3342

data/README.md

@@ -36,17 +36,17 @@ response = client.post('/any/path', :query => {:id => 1337}, :body => { :attribu
 puts response.body, response.code, response.message, response.headers.inspect
 ```
 
-That's about it! Cottus exposes almost all of the same methods with the same semantics as
-HTTParty does, with the exception of ```HTTParty#copy```.
+That's about it! Cottus exposes almost all of the same methods with similar semantics as
+Excon does.
 
 ## Strategy
 
-A "Strategy" is merely a class implementing an ```execute``` method that is
-responsible for carrying out the action specified by the passed ```meth```
+A "Strategy" is merely a class implementing an `execute` method that is
+responsible for carrying out the action specified by the passed `meth`
 argument.
 
-The Strategy class must however also implement an ```#initialize``` method which
-takes two parameters: ```connections``` and an ```options``` hash:
+The Strategy class must however also implement an `#initialize` method which
+takes two parameters: `connections` and an `options` hash:
 
 ```ruby
 class SomeStrategy
@@ -59,7 +59,7 @@ class SomeStrategy
 end
 ```
 
-If you don't mind inheritance there's a base class (```Cottus::Strategy```) that
+If you don't mind inheritance there's a base class (`Cottus::Strategy`) that
 you can inherit from and the above class would instead become:
 
 ```ruby
@@ -71,13 +71,13 @@ 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
-variable (```@connections```) on your own.
+`#initialize` make sure to call `#super` or set the required instance
+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.
 
-See ```lib/cottus/strategies.rb``` for further examples.
+See `lib/cottus/strategies.rb` for further examples.
 
 ### Using your own strategy
 
@@ -92,7 +92,7 @@ client = Cottus::Client.new(['http://n1.com', 'http://n2.com'], :strategy => MyS
 
 Want some additional options passed when your strategy is initialized?
 
-No problem! Pass them into the ```strategy_options``` sub-hash of the options
+No problem! Pass them into the `strategy_options` sub-hash of the options
 hash to the client.
 
 ```ruby

data/lib/cottus.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'httparty'
+require 'excon'
 
 require 'cottus/forward'
 require 'cottus/client'

data/lib/cottus/client.rb

@@ -21,7 +21,7 @@ module Cottus
 
     def create_connections(hosts)
       hosts = hosts.is_a?(String) ? hosts.split(',') : hosts
-      hosts.map { |host| Connection.new(http, host) }
+      hosts.map { |host| Connection.new(Excon.new(host)) }
     end
 
     def create_strategy(options)
@@ -29,9 +29,5 @@ module Cottus
       strategy_impl = options[:strategy] || RoundRobinStrategy
       strategy_impl.new(connections, strategy_options)
     end
-
-    def http
-      HTTParty
-    end
   end
 end

data/lib/cottus/connection.rb

@@ -8,14 +8,18 @@ module Cottus
 
     attr_reader :host
 
-    def initialize(*args)
-      @http, @host = *args
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def host
+      @connection.data[:host]
     end
 
     private
 
-    def wrapper(verb, path, options={}, &blk)
-      @http.send(verb, @host + path, options, &blk)
+    def wrapper(verb, path, options={})
+      @connection.send(verb, options.merge({path: path}))
     end
   end
 end

data/lib/cottus/forward.rb

@@ -7,11 +7,11 @@ module Cottus
       to, through = options.values_at(:to, :through)
 
       args.each do |verb|
-        define_method(verb) do |path, opts={}, &blk|
+        define_method(verb) do |path, opts={}|
           if to && through
-            instance_variable_get(to).send(through, verb, path, opts, &blk)
+            instance_variable_get(to).send(through, verb, path, opts)
           else
-            self.send(to, verb, path, opts, &blk)
+            self.send(to, verb, path, opts)
           end
         end
       end

data/lib/cottus/strategies.rb

@@ -4,6 +4,7 @@ module Cottus
 
   VALID_EXCEPTIONS = [
     Timeout::Error,
+    Excon::Errors::Timeout,
     Errno::ECONNREFUSED,
     Errno::ETIMEDOUT,
     Errno::ECONNRESET
@@ -14,7 +15,7 @@ module Cottus
       @connections = connections
     end
 
-    def execute(meth, path, options={}, &block)
+    def execute(meth, path, options={})
       raise NotImplementedError, 'implement me in subclass'
     end
   end
@@ -27,11 +28,11 @@ module Cottus
       @mutex = Mutex.new
     end
 
-    def execute(meth, path, options={}, &block)
+    def execute(meth, path, options={})
       tries = 0
 
       begin
-        next_connection.send(meth, path, options, &block)
+        next_connection.send(meth, path, options)
       rescue *VALID_EXCEPTIONS => e
         if tries >= @connections.count
           raise e
@@ -60,12 +61,12 @@ module Cottus
       @timeouts = options[:timeouts] || [1, 3, 5]
     end
 
-    def execute(meth, path, options={}, &block)
+    def execute(meth, path, options={})
       tries = 0
       starting_connection = connection = next_connection
 
       begin
-        connection.send(meth, path, options, &block)
+        connection.send(meth, path, options)
       rescue *VALID_EXCEPTIONS => e
         if tries < @timeouts.size
           sleep @timeouts[tries]

data/lib/cottus/version.rb

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

data/spec/acceptance/cottus_acceptance_spec.rb

@@ -6,7 +6,7 @@ module Cottus
   describe 'Client acceptance spec' do
     shared_examples 'exception handling' do
       context 'exceptions' do
-        context 'Timeout::Error' do
+        context 'Excon::Errors::Timeout' do
           it 'attempts to use each host until one succeeds' do
             stub_request(verb, 'http://localhost:1234/some/path').to_timeout
             stub_request(verb, 'http://localhost:12345/some/path').to_timeout
@@ -21,7 +21,7 @@ module Cottus
             stub_request(verb, 'http://localhost:12345/some/path').to_timeout
             stub_request(verb, 'http://localhost:12343/some/path').to_timeout
 
-            expect { client.send(verb, '/some/path') }.to raise_error(Timeout::Error)
+            expect { client.send(verb, '/some/path') }.to raise_error(Excon::Errors::Timeout)
           end
         end
 
@@ -147,16 +147,6 @@ module Cottus
       end
     end
 
-    describe '#move' do
-      include_examples 'load balancing' do
-        let(:verb) { :move }
-      end
-
-      include_examples 'exception handling' do
-        let(:verb) { :move }
-      end
-    end
-
     describe '#options' do
       include_examples 'load balancing' do
         let(:verb) { :options }
@@ -166,17 +156,5 @@ module Cottus
         let(:verb) { :options }
       end
     end
-
-    describe '#copy' do
-      pending do
-        include_examples 'load balancing' do
-          let(:verb) { :options }
-        end
-
-        include_examples 'exception handling' do
-          let(:verb) { :options }
-        end
-      end
-    end
   end
 end

data/spec/cottus/client_spec.rb

@@ -6,13 +6,13 @@ module Cottus
   describe Client do
     describe '#initialize' do
       it 'accepts an array of hosts w/ ports' do
-        client = described_class.new(['host1:123', 'host2:125'])
-        expect(client.hosts).to eq ['host1:123', 'host2:125']
+        client = described_class.new(['http://host1:123', 'http://host2:125'])
+        expect(client.hosts).to eq ['host1', 'host2']
       end
 
       it 'accepts a connection string w/ ports' do
-        client = described_class.new('host1:1255,host2:1255,host3:1255')
-        expect(client.hosts).to eq ['host1:1255', 'host2:1255', 'host3:1255']
+        client = described_class.new('http://host1:1255,http://host2:1255,http://host3:1255')
+        expect(client.hosts).to eq ['host1', 'host2', 'host3']
       end
     end
 

data/spec/cottus/strategies_spec.rb

@@ -8,16 +8,20 @@ module Cottus
       described_class.new(connections)
     end
 
-    let :http do
+    let :first do
       double(:http, get: nil)
     end
 
-    let :hosts do
-      ['http://n1.com', 'http://n2.com']
+    let :second do
+      double(:http, get: nil)
+    end
+
+    let :third do
+      double(:http, get: nil)
     end
 
     let :connections do
-      hosts.map { |host| Connection.new(http, host) }
+      [first, second, third]
     end
 
     describe '#execute' do
@@ -29,47 +33,47 @@ module Cottus
 
   shared_examples 'a round-robin strategy' do
     context 'with a single host' do
-      let :hosts do
-        ['n1']
+      let :connections do
+        [first]
       end
 
       it 'uses the single host for the first request' do
         strategy.execute(:get, '/some/path', query: { query: 1 })
 
-        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).once
+        expect(first).to have_received(:get).with('/some/path', query: { query: 1 }).once
       end
 
       it 'uses the single host for the second request' do
         2.times { strategy.execute(:get, '/some/path', query: { query: 1 }) }
 
-        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).twice
+        expect(first).to have_received(:get).with('/some/path', query: { query: 1 }).twice
       end
     end
 
     context 'with several hosts' do
-      let :hosts do
-        ['n1', 'n2', 'n3']
+      let :connections do
+        [first, second, third]
       end
 
       it 'uses the first host for the first request' do
         strategy.execute(:get, '/some/path', query: { query: 1 })
 
-        expect(http).to have_received(:get).with('n1/some/path', query: { query: 1 }).once
+        expect(first).to have_received(:get).with('/some/path', query: { query: 1 }).once
       end
 
       it 'uses the second host for the second request' do
         2.times { strategy.execute(:get, '/some/path', query: { query: 1 }) }
 
-        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(first).to have_received(:get).with('/some/path', query: { query: 1 }).once
+        expect(second).to have_received(:get).with('/some/path', query: { query: 1 }).once
       end
 
       it 'uses each host in turn' do
         3.times { strategy.execute(:get, '/some/path', query: { query: 1 }) }
 
-        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
+        expect(first).to have_received(:get).with('/some/path', query: { query: 1 }).once
+        expect(second).to have_received(:get).with('/some/path', query: { query: 1 }).once
+        expect(third).to have_received(:get).with('/some/path', query: { query: 1 }).once
       end
     end
   end
@@ -79,12 +83,16 @@ module Cottus
       described_class.new(connections)
     end
 
-    let :http do
+    let :first do
       double(:http, get: nil)
     end
 
-    let :connections do
-      hosts.map { |host| Connection.new(http, host) }
+    let :second do
+      double(:http, get: nil)
+    end
+
+    let :third do
+      double(:http, get: nil)
     end
 
     describe '#execute' do
@@ -96,31 +104,31 @@ module Cottus
         [Timeout::Error, Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::ECONNRESET].each do |error|
           context "when #{error} is raised" do
             context 'with a single host' do
-              let :hosts do
-                ['n1']
+              let :connections do
+                [first]
               end
 
               it 'gives up' do
-                hosts.each { |h| http.stub(:get).with("#{h}/some/path", {}).and_raise(error) }
+                connections.each { |conn| conn.stub(:get).with('/some/path', {}).and_raise(error) }
 
                 expect { strategy.execute(:get, '/some/path') }.to raise_error(error)
               end
             end
 
             context 'with several hosts' do
-              let :hosts do
-                ['n1', 'n2', 'n3']
+              let :connections do
+                [first, second, third]
               end
 
               it 'attempts to use each host until one succeeds' do
-                ['n1', 'n2'].each { |h| http.stub(:get).with("#{h}/some/path", {}).and_raise(error) }
+                [first, second].each { |conn| conn.stub(:get).with('/some/path', {}).and_raise(error) }
 
                 strategy.execute(:get, '/some/path')
-                expect(http).to have_received(:get).with('n3/some/path', {})
+                expect(third).to have_received(:get).with('/some/path', {})
               end
 
               it 'gives up after trying all hosts' do
-                hosts.each { |h| http.stub(:get).with("#{h}/some/path", {}).and_raise(error) }
+                connections.each { |conn| conn.stub(:get).with('/some/path', {}).and_raise(error) }
 
                 expect { strategy.execute(:get, '/some/path') }.to raise_error(error)
               end
@@ -136,12 +144,16 @@ module Cottus
       described_class.new(connections, timeouts: [0, 0, 0])
     end
 
-    let :http do
+    let :first do
       double(:http, get: nil)
     end
 
-    let :connections do
-      hosts.map { |host| Connection.new(http, host) }
+    let :second do
+      double(:http, get: nil)
+    end
+
+    let :third do
+      double(:http, get: nil)
     end
 
     describe '#execute' do
@@ -153,20 +165,20 @@ module Cottus
         [Timeout::Error, Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::ECONNRESET].each do |error|
           context "when #{error} is raised" do
             context 'with a single host' do
-              let :hosts do
-                ['n1']
+              let :connections do
+                [first]
               end
 
               it 'uses the single host for three consecutive exceptions' do
-                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(first).to receive(:get).with('/some/path', {}).exactly(3).times.and_raise(error)
+                expect(first).to receive(:get).with('/some/path', {}).once
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
                 strategy.execute(:get, '/some/path')
               end
 
               it 'gives up after three retries' do
-                expect(http).to receive(:get).with('n1/some/path', {}).exactly(4).times.and_raise(error)
+                expect(first).to receive(:get).with('/some/path', {}).exactly(4).times.and_raise(error)
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
                 expect { strategy.execute(:get, '/some/path') }.to raise_error(error)
@@ -174,21 +186,21 @@ module Cottus
             end
 
             context 'with several hosts' do
-              let :hosts do
-                ['n1', 'n2', 'n3']
+              let :connections do
+                [first, second, third]
               end
 
               it 'uses the same host for three consecutive exceptions' do
-                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(first).to receive(:get).with('/some/path', {}).exactly(3).times.and_raise(error)
+                expect(first).to receive(:get).with('/some/path', {}).once
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
                 strategy.execute(:get, '/some/path')
               end
 
               it 'switches host after three retries' do
-                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(first).to receive(:get).with('/some/path', {}).exactly(4).times.and_raise(error)
+                expect(second).to receive(:get).with('/some/path', {}).once
                 expect(strategy).to receive(:sleep).with(0).exactly(3).times
 
                 strategy.execute(:get, '/some/path')

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: cottus
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Mathias Söderberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-12 00:00:00.000000000 Z
+date: 2013-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: excon
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='