etcd-rb 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5096dd7b703a7f42348e4eaae037cfa642e054f
-  data.tar.gz: 8f93a5c5affe7ffaaa0557a7df893a2fa6d9f00c
+  metadata.gz: 3f44e73b7a78f25139d79210e6802c4837b116e6
+  data.tar.gz: ffbe7d2df48e3cc9e050a127b605d412c2a352f6
 SHA512:
-  metadata.gz: 64631fd825ea6326288c8730f60539afd63e62f12015a657232e663153564ce628025f78b5c7026844901c790a76cbcddd70bb36963af529e7c3f8871b29a7d4
-  data.tar.gz: a2170e3f1d2ea0d9dfac6353d221539f593cc534083782bf2a53704907429adf9cbd2da3ec844a2d6d956571ce9ee08b50fe7416160127edb449dc2d8d5bf8d4
+  metadata.gz: 2b6de922dd29798bb860b69081d8c0e1ba16fc06a89ab985c7f6f7f4e3bc0cb288c045bd65cfbe527fcafbec1ec301a69aee5879b647dcd0e331195620fe207e
+  data.tar.gz: e43e9f2006c706bff16b6a3985d0d554c38b566379f2e87dabe87006b4c6e39980bce142ad4445dc9a216e373cd9d4dc5dfce6ef34177b329ccfe0f01a2dc8f3

data/README.md

@@ -5,10 +5,10 @@
 
 # Requirements
 
-  - A modern Ruby, compatible with 1.9.3 or later. Continously tested with MRI 1.9.3, 2.0.0 and JRuby 1.7.x.
   - Linux/OSX OS
-  - to have a local Etcd binary, run
-    - `$ sh/install-etcd.sh`
+  - A modern Ruby, compatible with 2.0.0 or later. Continously tested with MRI 2.0.0, 2.2 and JRuby 9.0.0.
+  - Etcd 2.0.0 or later (only the V2 API is supported). To have a local etcd binary, run:
+      - `$ sh/install-etcd.sh`
 
 # Installation
 
@@ -214,4 +214,4 @@ _Licensed under the Apache License, Version 2.0 (the "License"); you may not use
 
 [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
 
-_Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License._
+_Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License._

data/lib/etcd/client/failover.rb

@@ -1,7 +1,5 @@
 module Etcd
   class Client
-
-
     # @param options [Hash]
     # @option options [Array] :uris (['http://127.0.0.1:4001']) seed uris with etcd cluster nodes
     # @option options [Float] :heartbeat_freq (0.0) check-frequency for leader status (in seconds)
@@ -34,7 +32,6 @@ module Etcd
       self
     end
 
-
     # Creates a Cluster-instance from `@seed_uris`
     # and stores the cluster leader information
     def update_cluster
@@ -59,10 +56,9 @@ module Etcd
     end
 
     def leader_uri
-      leader && leader.etcd
+      leader && leader.client_urls && leader.client_urls.first
     end
 
-
     def start_heartbeat_if_needed
       logger.debug("client - starting heartbeat")
       @heartbeat = Etcd::Heartbeat.new(self, @heartbeat_freq)
@@ -77,27 +73,26 @@ module Etcd
       http_client.default_redirect_uri_callback(uri, response)
     end
 
+    private
 
-private
     # :uri and :request_data are the only methods calling :leader method
     # so they both need to handle the case for missing leader in cluster
     def uri(key, action=S_KEYS)
       raise AllNodesDownError unless leader
       key = "/#{key}" unless key.start_with?(S_SLASH)
-      "#{leader_uri}/v1/#{action}#{key}"
+      "#{leader_uri}/v2/#{action}#{key}"
     end
 
-
     def request_data(method, uri, args={})
       logger.debug("request_data:  #{method} - #{uri} #{args.inspect}")
       begin
         super
       rescue Errno::ECONNREFUSED, HTTPClient::TimeoutError => e
         logger.debug("request_data:  re-election handling")
-        old_leader_uri = @leader.etcd
+        old_leader_uri = @leader.client_urls.first
         update_cluster
         if @leader
-          uri = uri.gsub(old_leader_uri, @leader.etcd)
+          uri = uri.gsub(old_leader_uri, @leader.client_urls.first)
           retry
         else
           raise AllNodesDownError
@@ -106,4 +101,4 @@ private
     end
 
   end
-end
+end

data/lib/etcd/client/observing.rb

@@ -31,8 +31,8 @@ module Etcd
     #
     # @return [#cancel, #join] an observer object which you can call cancel and
     #   join on
-    def observe(prefix, &handler)
-      ob = Observer.new(self, prefix, handler).tap(&:run)
+    def observe(prefix, options = {}, &handler)
+      ob = Observer.new(self, prefix, handler, options).tap(&:run)
       @observers[prefix] = ob
       ob
     end

data/lib/etcd/client/protocol.rb

@@ -1,3 +1,12 @@
+# Implements the etcd V2 client API
+#
+# Sample API requests/responses
+# $ curl -L http://127.0.0.1:4001/v2/keys
+# {"action":"get","node":{"dir":true,"nodes":[{"key":"/foo","value":"bar","modifiedIndex":22,"createdIndex":22}]}}
+#
+# $ curl -L http://127.0.0.1:4001/v2/keys/foo
+# {"action":"get","node":{"key":"/foo","value":"bar","modifiedIndex":22,"createdIndex":22}}
+
 module Etcd
   class Client
 
@@ -15,8 +24,8 @@ module Etcd
     def set(key, value, options={})
       body       = {:value => value}
       body[:ttl] = options[:ttl] if options[:ttl]
-      data       = request_data(:post, key_uri(key), body: body)
-      data[S_PREV_VALUE]
+      data       = request_data(:PUT, key_uri(key), body: body)
+      data[S_PREV_NODE][S_VALUE] if data && data[S_PREV_NODE]
     end
 
     # Gets the value or values for a key.
@@ -30,12 +39,12 @@ module Etcd
     def get(key)
       data = request_data(:get, key_uri(key))
       return nil unless data
-      if data.is_a?(Array)
-        data.each_with_object({}) do |e, acc|
-          acc[e[S_KEY]] = e[S_VALUE]
+      if nodes = data[S_NODE][S_NODES]
+        nodes.each_with_object({}) do |node, acc|
+          acc[node[S_KEY]] = node[S_VALUE]
         end
       else
-        data[S_VALUE]
+        data[S_NODE][S_VALUE]
       end
     end
 
@@ -58,7 +67,7 @@ module Etcd
     def update(key, value, expected_value, options={})
       body       = {:value => value, :prevValue => expected_value}
       body[:ttl] = options[:ttl] if options[:ttl]
-      data       = request_data(:post, key_uri(key), body: body)
+      data       = request_data(:put, key_uri(key), body: body)
       !! data
     end
 
@@ -71,7 +80,7 @@ module Etcd
     def delete(key)
       data = request_data(:delete, key_uri(key))
       return nil unless data
-      data[S_PREV_VALUE]
+      data[S_PREV_NODE][S_VALUE]
     end
 
     # Returns true if the specified key exists.
@@ -102,8 +111,8 @@ module Etcd
     def info(key)
       data = request_data(:get, uri(key))
       return nil unless data
-      if data.is_a?(Array)
-        data.each_with_object({}) do |d, acc|
+      if nodes = data[S_NODE][S_NODES]
+        nodes.each_with_object({}) do |d, acc|
           info = extract_info(d)
           info.delete(:action)
           acc[info[:key]] = info
@@ -140,14 +149,10 @@ module Etcd
     # @yieldparam [Hash] info the info for the key that changed
     # @return [Object] the result of the given block
     def watch(prefix, options={})
-      if options[:index]
-        parameters = {:index => options[:index]}
-        data       = request_data(:post, watch_uri(prefix), query: parameters)
-      else
-        data       = request_data(:get, watch_uri(prefix), query: {})
-      end
-
-      info         = extract_info(data)
+      options.merge!(wait: 'true')
+      options.delete(:index) if options.has_key?(:index) && options[:index].nil?
+      data = request_data(:get, watch_uri(prefix), query: options)
+      info = extract_info(data)
       yield info[:value], info[:key], info
     end
 
@@ -157,30 +162,35 @@ module Etcd
     end
 
     def watch_uri(key)
-      uri(key, S_WATCH)
+      uri(key, S_KEYS)
     end
 
 private
 
     def extract_info(data)
+      if data[S_NODE]
+        node = data[S_NODE]
+      else
+        node = data
+      end
+      return {} unless node
       info = {
-        :key   => data[S_KEY],
-        :value => data[S_VALUE],
-        :index => data[S_INDEX],
+        :key   => node[S_KEY],
+        :value => node[S_VALUE],
+        :index => node[S_INDEX],
       }
-      expiration_s          = data[S_EXPIRATION]
-      ttl                   = data[S_TTL]
-      previous_value        = data[S_PREV_VALUE]
+      expiration_s          = node[S_EXPIRATION]
+      ttl                   = node[S_TTL]
       action_s              = data[S_ACTION]
+      previous_node         = data[S_PREV_NODE]
       info[:expiration]     = Time.iso8601(expiration_s) if expiration_s
       info[:ttl]            = ttl if ttl
-      info[:new_key]        = data[S_NEW_KEY] if data.include?(S_NEW_KEY)
-      info[:dir]            = data[S_DIR] if data.include?(S_DIR)
-      info[:previous_value] = previous_value if previous_value
+      info[:dir]            = node[S_DIR] if node.include?(S_DIR)
+      info[:previous_value] = previous_node[S_VALUE] if previous_node
       info[:action]         = action_s.downcase.to_sym if action_s
+      info[:new_key]        = !data[S_PREV_NODE]
       info
     end
 
-
   end
-end
+end

data/lib/etcd/cluster.rb

@@ -24,21 +24,15 @@ module Etcd
       end
 
       def status_uri(uri)
-        "#{uri}/v1/keys/_etcd/machines/"
+        "#{uri}/v2/members/"
       end
 
       def parse_cluster_status(cluster_status_response)
-        cluster_status_response.map do |attrs|
-          node_name = attrs[S_KEY].split(S_SLASH).last
-          urls      = attrs[S_VALUE].split(S_AND)
-          etcd      = urls.grep(/etcd/).first.split("=").last
-          raft      = urls.grep(/raft/).first.split("=").last
-          {:name => node_name, :raft => raft, :etcd => etcd}
+        cluster_status_response['members'].map do |attrs|
+          Etcd::Node.parse_node_data(attrs)
         end
       end
 
-
-
       # @example
       #   Etcd::Cluster.nodes_from_uri("http://127.0.0.1:4001")
       #
@@ -50,8 +44,8 @@ module Etcd
       end
 
       def nodes_from_attributes(node_attributes)
-        res = node_attributes.map do |attr|
-          Etcd::Node.new(attr)
+        res = node_attributes.map do |attrs|
+          Etcd::Node.new(attrs)
         end
       end
 
@@ -95,4 +89,4 @@ module Etcd
       nodes.select{|x| x.is_leader}.first
     end
   end
-end
+end

data/lib/etcd/constants.rb

@@ -1,18 +1,18 @@
 module Etcd
   module Constants
+    S_NODE                = 'node'.freeze
+    S_NODES               = 'nodes'.freeze
     S_KEY                 = 'key'.freeze
     S_KEYS                = 'keys'.freeze
     S_VALUE               = 'value'.freeze
     S_INDEX               = 'index'.freeze
     S_EXPIRATION          = 'expiration'.freeze
     S_TTL                 = 'ttl'.freeze
-    S_NEW_KEY             = 'newKey'.freeze
     S_DIR                 = 'dir'.freeze
-    S_PREV_VALUE          = 'prevValue'.freeze
+    S_PREV_NODE           = 'prevNode'.freeze
     S_ACTION              = 'action'.freeze
-    S_WATCH               = 'watch'.freeze
     S_LOCATION            = 'location'.freeze
     S_SLASH               = '/'.freeze
     S_AND                 = '&'.freeze
   end
-end
+end

data/lib/etcd/heartbeat.rb

@@ -13,7 +13,7 @@ module Etcd
     # Initiates heartbeating the leader node in a background thread
     # ensures, that observers are refreshed after leader re-election
     def start_heartbeat_if_needed
-      logger.debug ("start_heartbeat_if_needed - enter")
+      logger.debug("start_heartbeat_if_needed - enter")
       return if freq == 0
       return if @heartbeat_thread
       @heartbeat_thread = Thread.new do
@@ -41,4 +41,4 @@ module Etcd
     end
 
   end
-end
+end

data/lib/etcd/loggable.rb

@@ -10,4 +10,4 @@ module Etcd::Loggable
       log
     end
   end
-end
+end

data/lib/etcd/node.rb

@@ -2,44 +2,61 @@ module Etcd
   class Node
     include Etcd::Constants
     include Etcd::Requestable
-    attr_accessor :name, :etcd, :raft
+    attr_accessor :name, :id, :peer_urls, :client_urls
     # possible values: :unknown, :running, :down
     attr_accessor :status
     attr_accessor :is_leader
 
+    class << self
+      def parse_node_data(attrs)
+        {
+          :id          => attrs["id"],
+          :name        => attrs["name"],
+          :peer_urls   => attrs["peerURLs"],
+          :client_urls => attrs["clientURLs"]
+        }
+      end
+    end
+
     def initialize(opts={})
       check_required(opts)
-      @name   = opts[:name]
-      @etcd   = URI.decode(opts[:etcd])
-      @raft   = URI.decode(opts[:raft])
+      @name        = opts[:name]
+      @id          = opts[:id]
+      @peer_urls   = opts[:peer_urls]
+      @client_urls = opts[:client_urls]
       @status = :unknown
     end
 
     def check_required(opts)
-      raise ArgumentError, "etcd URL is required!" unless opts[:etcd]
+      raise ArgumentError, "Client URL is required!" unless opts[:client_urls] && opts[:client_urls].any?
+      raise ArgumentError, "Node ID is required!" unless opts[:id]
     end
 
     def update_status
       begin
-        response   = request(:get, leader_uri)
-        @status    = :running
-        @is_leader = (response.body == @raft)
+        leader_data = request_data(:get, leader_uri)
+        @status     = :running
+        @is_leader  = (leader_data["id"] == @id)
       rescue HTTPClient::TimeoutError, Errno::ECONNREFUSED => e
         @status = :down
       end
     end
 
     def leader_uri
-      "#{@etcd}/v1/leader"
+      "#{@client_urls.first}/v2/members/leader"
     end
 
     def inspect
-      %Q(<#{self.class} - #{name_with_status} - #{etcd}>)
+      %Q(<#{self.class} - #{id} - #{name_with_status} - #{peer_urls}>)
     end
 
     def name_with_status
       print_status = @is_leader ? "leader" : status
       "#{name} (#{print_status})"
     end
+
+    def to_json
+      { :name => name, :id => id, :client_urls => client_urls, :peer_urls => peer_urls }.to_json
+    end
   end
 end

data/lib/etcd/observer.rb

@@ -2,10 +2,11 @@ module Etcd
   class Observer
     include Etcd::Loggable
 
-    def initialize(client, prefix, handler)
+    def initialize(client, prefix, handler, options = {})
       @client  = client
       @prefix  = prefix
       @handler = handler
+      @options = options
       @index   = nil
       reset_logger!(Logger::DEBUG)
     end
@@ -15,7 +16,7 @@ module Etcd
       @thread = Thread.start do
         while @running
           logger.debug "********* watching #{@prefix} with index #{@index}"
-          @client.watch(@prefix, index: @index) do |value, key, info|
+          @client.watch(@prefix, @options.merge(index: @index)) do |value, key, info|
             if @running
               logger.debug "watch fired for #{@prefix} with #{info.inspect} "
               call_handler_in_needed(value, key, info)

data/lib/etcd/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Etcd
-  VERSION = '1.0.0'.freeze
-end
+  VERSION = '1.1.0'.freeze
+end

data/spec/etcd/client_spec.rb

@@ -2,12 +2,13 @@
 require 'spec_helper'
 
 module Etcd
+
   describe Client do
     include ClusterHelper
     include ClientHelper
 
     def base_uri
-      "http://127.0.0.1:4001/v1"
+      "http://127.0.0.1:4001/v2"
     end
 
     let :client do
@@ -16,7 +17,7 @@ module Etcd
 
     describe '#get' do
       before do
-        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'value' => 'bar'}))
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'node' => {'value' => 'bar'}}))
       end
 
       it 'sends a GET request to retrieve the value for a key' do
@@ -30,7 +31,7 @@ module Etcd
       end
 
       it 'parses the response and returns the value' do
-        client.get('/foo').should == 'bar'
+        client.get('/foo').should eq('bar')
       end
 
       it 'returns nil if when the key does not exist' do
@@ -40,10 +41,10 @@ module Etcd
 
       context 'when listing a prefix' do
         it 'returns a hash of keys and their values' do
-          values = [
+          values = {'node' => {'nodes' => [
             {'key' => '/foo/bar', 'value' => 'bar'},
-            {'key' => '/foo/baz', 'value' => 'baz'},
-          ]
+            {'key' => '/foo/baz', 'value' => 'baz'}
+          ]}}
           stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump(values))
           client.get('/foo').should eql({'/foo/bar' => 'bar', '/foo/baz' => 'baz'})
         end
@@ -53,65 +54,65 @@ module Etcd
 
     describe '#set' do
       before do
-        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        stub_request(:put, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevNode' => {'value' => 1}}))
       end
 
-      it 'sends a POST request to set the value for a key' do
+      it 'sends a PUT request to set the value for a key' do
         client.set('/foo', 'bar')
-        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar')
+        WebMock.should have_requested(:put, "#{base_uri}/keys/foo").with(body: 'value=bar')
       end
 
       it 'prepends a slash to keys when necessary' do
         client.set('foo', 'bar')
-        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar')
+        WebMock.should have_requested(:put, "#{base_uri}/keys/foo").with(body: 'value=bar')
       end
 
       it 'parses the response and returns the previous value' do
-        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevValue' => 'baz'}))
-        client.set('/foo', 'bar').should == 'baz'
+        stub_request(:put, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevNode' => {'value' => 'baz'}}))
+        client.set('/foo', 'bar').should eq('baz')
       end
 
       it 'returns nil when there is no previous value' do
-        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        stub_request(:put, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
         client.set('/foo', 'bar').should be_nil
       end
 
       it 'sets a TTL when the :ttl option is given' do
         client.set('/foo', 'bar', ttl: 3)
-        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar&ttl=3')
+        WebMock.should have_requested(:put, "#{base_uri}/keys/foo").with(body: 'value=bar&ttl=3')
       end
     end
 
     describe '#update' do
       before do
-        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        stub_request(:put, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
       end
 
       it 'sends a POST request to set the value conditionally' do
         client.update('/foo', 'bar', 'baz')
-        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar&prevValue=baz')
+        WebMock.should have_requested(:put, "#{base_uri}/keys/foo").with(body: 'value=bar&prevValue=baz')
       end
 
       it 'returns true when the key is successfully changed' do
-        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        stub_request(:put, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
         client.update('/foo', 'bar', 'baz').should eq(true)
       end
 
       it 'returns false when an error is returned' do
-        stub_request(:post, "#{base_uri}/keys/foo").to_return(status: 400, body: MultiJson.dump({}))
+        stub_request(:put, "#{base_uri}/keys/foo").to_return(status: 400, body: MultiJson.dump({}))
         client.update('/foo', 'bar', 'baz').should eq(false)
       end
 
       it 'sets a TTL when the :ttl option is given' do
         client.update('/foo', 'bar', 'baz', ttl: 3)
-        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar&prevValue=baz&ttl=3')
+        WebMock.should have_requested(:put, "#{base_uri}/keys/foo").with(body: 'value=bar&prevValue=baz&ttl=3')
       end
     end
 
 
     describe '#delete' do
       before do
-        stub_request(:delete, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        stub_request(:delete, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevNode' => {'value' => 1}}))
       end
 
       it 'sends a DELETE request to remove a key' do
@@ -120,8 +121,8 @@ module Etcd
       end
 
       it 'returns the previous value' do
-        stub_request(:delete, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevValue' => 'bar'}))
-        client.delete('/foo').should == 'bar'
+        stub_request(:delete, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevNode' => {'value' => 'bar'}}))
+        client.delete('/foo').should eq('bar')
       end
 
       it 'returns nil when there is no previous value' do
@@ -132,7 +133,7 @@ module Etcd
 
     describe '#exists?' do
       it 'returns true if the key has a value' do
-        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'value' => 'bar'}))
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'node' => {'value' => 'bar'}}))
         client.exists?('/foo').should eq(true)
       end
 
@@ -144,32 +145,32 @@ module Etcd
 
     describe '#info' do
       it 'returns the key, value, index, expiration and TTL for a key' do
-        body = MultiJson.dump({'action' => 'GET', 'key' => '/foo', 'value' => 'bar', 'index' => 31, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7})
+        body = MultiJson.dump({'action' => 'get', 'node' => {'key' => '/foo', 'value' => 'bar', 'index' => 31, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7}})
         stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
         info = client.info('/foo')
-        info[:key].should == '/foo'
-        info[:value].should == 'bar'
-        info[:index].should == 31
+        info[:key].should eq('/foo')
+        info[:value].should eq('bar')
+        info[:index].should eq(31)
         # rounding because of ruby 2.0 time parsing bug @see https://gist.github.com/mindreframer/6746829
-        info[:expiration].to_f.round.should == (Time.utc(2013, 12, 11, 10, 9, 8) + 0.123).to_f.round
-        info[:ttl].should == 7
+        info[:expiration].to_f.round.should eq((Time.utc(2013, 12, 11, 10, 9, 8) + 0.123).to_f.round)
+        info[:ttl].should eq(7)
       end
 
       it 'returns the dir flag' do
-        body = MultiJson.dump({'action' => 'GET', 'key' => '/foo', 'dir' => true})
+        body = MultiJson.dump({'action' => 'get', 'node' => {'key' => '/foo', 'dir' => true}})
         stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
         info = client.info('/foo')
-        info[:key].should == '/foo'
+        info[:key].should eq('/foo')
         info[:dir].should eq(true)
       end
 
       it 'returns only the pieces of information that are returned' do
-        body = MultiJson.dump({'action' => 'GET', 'key' => '/foo', 'value' => 'bar', 'index' => 31})
+        body = MultiJson.dump({'action' => 'get', 'node' => {'key' => '/foo', 'value' => 'bar', 'index' => 31}})
         stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
         info = client.info('/foo')
-        info[:key].should == '/foo'
-        info[:value].should == 'bar'
-        info[:index].should == 31
+        info[:key].should eq('/foo')
+        info[:value].should eq('bar')
+        info[:index].should eq(31)
       end
 
       it 'returns nil when the key does not exist' do
@@ -179,18 +180,19 @@ module Etcd
 
       context 'when listing a prefix' do
         it 'returns a hash of keys and their info' do
-          body = MultiJson.dump([
+          body = MultiJson.dump({'node' => {'nodes' => [
             {'action' => 'GET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 31},
             {'action' => 'GET', 'key' => '/foo/baz', 'value' => 'baz', 'index' => 55},
-          ])
+          ]}})
           stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
           info = client.info('/foo')
-          info['/foo/bar'][:key].should == '/foo/bar'
-          info['/foo/baz'][:key].should == '/foo/baz'
-          info['/foo/bar'][:value].should == 'bar'
-          info['/foo/baz'][:value].should == 'baz'
-          info['/foo/bar'][:index].should == 31
-          info['/foo/baz'][:index].should == 55
+          puts info
+          info['/foo/bar'][:key].should eq('/foo/bar')
+          info['/foo/baz'][:key].should eq('/foo/baz')
+          info['/foo/bar'][:value].should eq('bar')
+          info['/foo/baz'][:value].should eq('baz')
+          info['/foo/bar'][:index].should eq(31)
+          info['/foo/baz'][:index].should eq(55)
         end
       end
     end
@@ -211,16 +213,16 @@ module Etcd
         with_stubbed_leaders(healthy_cluster_config)
 
         client = Etcd::Client.connect(:uris => etcd1_uri)
-        client.leader.etcd.should == etcd1_uri
-        client.leader.name.should == "node1"
+        client.leader.client_urls.first.should eq(etcd1_uri)
+        client.leader.name.should eq("node1")
 
         with_stubbed_leaders(healthy_cluster_changed_leader_config)
 
-        stub_request(:post, "#{etcd1_uri}/v1/keys/foo").to_return(status: 307, headers: {'Location' => "#{etcd2_uri}/v1/keys/foo"})
-        stub_request(:post, "#{etcd2_uri}/v1/keys/foo").to_return(body: MultiJson.dump({'value' => 'bar'}))
+        stub_request(:put, "#{etcd1_uri}/v2/keys/foo").to_return(status: 307, headers: {'Location' => "#{etcd2_uri}/v2/keys/foo"})
+        stub_request(:put, "#{etcd2_uri}/v2/keys/foo").to_return(body: MultiJson.dump({'value' => 'bar'}))
         client.set("foo", "bar")
-        client.leader.etcd.should == etcd2_uri
-        client.leader.name.should == "node2"
+        client.leader.client_urls.first.should eq(etcd2_uri)
+        client.leader.name.should eq("node2")
       end
     end