etcd-rb 1.0.0.pre1 → 1.0.0

data/spec/etcd/node_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+require 'spec_helper'
+
+
+module Etcd
+  describe Node do
+
+    def default_node(opts = {})
+      args = {:name => "node1", :etcd => "http://example.com:4001", :raft => "http://example.com:7001"}
+      Etcd::Node.new(args.merge(opts))
+    end
+
+    describe '#initialize' do
+      it "works with all required parameters" do
+        default_node({}).should_not == nil
+      end
+
+      it "raises if :etcd url is missing" do
+        expect {
+          default_node({:etcd => nil})
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '#update_status' do
+      it "sets status :running if alive" do
+        node = default_node
+        stub_request(:get, node.leader_uri).to_return(body: node.raft)
+        node.update_status
+        node.status.should == :running
+      end
+
+      it "sets status :down if down" do
+        node = default_node
+        stub_request(:get, node.leader_uri).to_timeout
+        node.update_status
+        node.status.should == :down
+      end
+
+      it "marks leader-flag if leader" do
+        node = default_node
+        stub_request(:get, node.leader_uri).to_return(body: node.raft)
+        node.update_status
+        node.is_leader.should eq(true)
+      end
+
+      it "marks leader-flag as :false if leader looses leadership" do
+        node = default_node
+        stub_request(:get, node.leader_uri).to_return(body: node.raft)
+        node.update_status
+        node.is_leader.should eq(true)
+        stub_request(:get, node.leader_uri).to_return(body: "bla")
+        node.update_status
+        node.is_leader.should eq(false)
+      end
+    end
+  end
+end

data/spec/etcd/observer_spec.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Etcd
+  describe Client do
+    include ClusterHelper
+    include ClientHelper
+
+    def base_uri
+      "http://127.0.0.1:4001/v1"
+    end
+
+    let :client do
+      default_client
+    end
+
+    describe '#watch' do
+      it 'sends a GET request for a watch of a key prefix' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({}))
+        client.watch('/foo') { }
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+      end
+
+      it 'sends a GET request for a watch of a key prefix from a specified index' do
+        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 3}).to_return(body: MultiJson.dump({}))
+        client.watch('/foo', index: 3) { }
+        WebMock.should have_requested(:post, "#{base_uri}/watch/foo").with(query: {'index' => 3})
+      end
+
+      it 'yields the value' do
+        body = MultiJson.dump({'value' => 'bar'})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        value = nil
+        client.watch('/foo') do |v|
+          value = v
+        end
+        value.should == 'bar'
+      end
+
+      it 'yields the changed key' do
+        body = MultiJson.dump({'key' => '/foo/bar', 'value' => 'bar'})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        key = nil
+        client.watch('/foo') do |_, k|
+          key = k
+        end
+        key.should == '/foo/bar'
+      end
+
+      it 'yields info about the key, when it is a new key' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'newKey' => true})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        info = nil
+        client.watch('/foo') do |_, _, i|
+          info = i
+        end
+        info[:action].should == :set
+        info[:key].should == '/foo/bar'
+        info[:value].should == 'bar'
+        info[:index].should == 3
+        info[:new_key].should eq(true)
+      end
+
+      it 'yields info about the key, when the key was changed' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'prevValue' => 'baz', 'index' => 3})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        info = nil
+        client.watch('/foo') do |_, _, i|
+          info = i
+        end
+        info[:action].should == :set
+        info[:key].should == '/foo/bar'
+        info[:value].should == 'bar'
+        info[:index].should == 3
+        info[:previous_value].should == 'baz'
+      end
+
+      it 'yields info about the key, when the key has a TTL' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        info = nil
+        client.watch('/foo') do |_, _, i|
+          info = i
+        end
+        info[:action].should == :set
+        info[:key].should == '/foo/bar'
+        info[:value].should == 'bar'
+        info[:index].should == 3
+        # 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
+      end
+
+      it 'returns the return value of the block' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        return_value = client.watch('/foo') do |_, k, _|
+          k
+        end
+        return_value.should == '/foo/bar'
+      end
+    end
+
+
+    describe '#observe' do
+      it 'watches the specified key prefix' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({}))
+        barrier = Queue.new
+        observer = client.observe('/foo') do
+          barrier << :ping
+          observer.cancel
+          observer.join
+        end
+        barrier.pop
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+      end
+
+      it 're-watches the prefix with the (last seen index + 1)  immediately' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({'index' => 3}))
+        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 4}).to_return(body: MultiJson.dump({'index' => 4}))
+        barrier = Queue.new
+        observer = client.observe('/foo') do |_, _, info|
+          if info[:index] == 4
+            barrier << :ping
+            observer.cancel
+            observer.join
+          end
+        end
+        barrier.pop
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+        WebMock.should have_requested(:post, "#{base_uri}/watch/foo").with(query: {'index' => 4})
+      end
+
+      it 'yields the value, key and info to the block given' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'newKey' => true}))
+        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 4}).to_return(body: MultiJson.dump({'action' => 'DELETE', 'key' => '/foo/baz', 'value' => 'foo', 'index' => 4}))
+        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 5}).to_return(body: MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'hello', 'index' => 5}))
+        barrier = Queue.new
+        values   = []
+        keys     = []
+        actions  = []
+        new_keys = []
+        observer = client.observe('/foo') do |value, key, info|
+          values    << value
+          keys      << key
+          actions   << info[:action]
+          new_keys  << info[:new_key]
+          if info[:index] == 5
+            barrier << :ping
+            observer.cancel
+            observer.join
+          end
+        end
+        barrier.pop
+        values.should   == %w[bar foo hello]
+        keys.should     == %w[/foo/bar /foo/baz /foo/bar]
+        actions.should  == [:set, :delete, :set]
+        new_keys.should == [true, nil, nil]
+      end
+    end
+
+  end
+end

data/spec/integration/etcd_spec.rb

@@ -4,9 +4,10 @@ require 'spec_helper'
 require 'open-uri'
 
 
-describe 'A etcd client' do
+describe 'With real server an etcd client' do
+
   let :client do
-    Etcd::Client.new(uri: ENV['ETCD_URI']).connect
+    Etcd::Client.test_client
   end
 
   let :prefix do
@@ -19,14 +20,15 @@ describe 'A etcd client' do
 
   before do
     WebMock.disable!
+    WebMock.allow_net_connect!
   end
 
   before do
-    begin
-      open("#{ENV['ETCD_URI']}/v1/leader").read
-    rescue Errno::ECONNREFUSED, Errno::ENOENT
-      pending('etcd not running, start it with `./spec/resources/etcd-cluster start`')
-    end
+    ClusterController.start_cluster
+  end
+
+  before do
+    pending('etcd could not be started, check it with `sh/cluster start`') unless client
   end
 
   before do
@@ -46,13 +48,44 @@ describe 'A etcd client' do
 
   it 'watches for changes to a key' do
     Thread.start { sleep(0.1); client.set(key, 'baz') }
-    new_value = client.watch(key) { |value| value }
+    new_value, info = *client.watch(key) { |v, k, info|  [v, info]  }
     new_value.should == 'baz'
+    info[:new_key].should == true
   end
 
   it 'conditionally sets the value for a key' do
     client.set(key, 'bar')
-    client.update(key, 'qux', 'baz').should be_false
-    client.update(key, 'qux', 'bar').should be_true
+    client.update(key, 'qux', 'baz').should eq(false)
+    client.update(key, 'qux', 'bar').should eq(true)
+  end
+
+
+  it "has heartbeat, that resets observed watches" do
+    ClusterController.start_cluster
+    client = Etcd::Client.test_client(:heartbeat_freq => 0.2)
+    client.cluster.nodes.map(&:status).uniq.should == [:running]
+    changes = Queue.new
+
+    client.observe('/foo') do |v,k,info|
+      puts "triggered #{info.inspect}"
+      changes << info
+    end
+
+    changes.size.should == 0
+
+    ### simulate second console
+    a = Thread.new do
+      client = Etcd::Client.test_client
+      ClusterController.kill_node(client.cluster.leader.name)
+      sleep 0.4
+      puts "1.st try"
+      client.set("/foo", "bar")
+      sleep 0.4
+      puts "2.nd try"
+      client.set("/foo", "barss")
+    end
+
+    sleep 1.5
+    changes.size.should == 2
   end
 end

data/spec/resources/cluster_controller.rb

@@ -0,0 +1,19 @@
+class ClusterController
+
+  def self.sh_path
+    File.expand_path(File.join(File.dirname(__FILE__), '..', '..', "sh"))
+  end
+
+  def self.kill_node(node_name)
+    node_pid = `ps -ef|grep #{node_name}|grep -v grep`.split[1]
+    `kill -9 #{node_pid}`
+  end
+
+  def self.start_cluster
+    `#{sh_path}/cluster start`
+  end
+
+  def self.stop_cluster
+    `#{sh_path}/cluster stop`
+  end
+end

data/spec/spec_helper.rb

@@ -18,7 +18,8 @@ unless ENV['COVERAGE'] == 'no'
   end
 end
 
-ENV['ETCD_URI'] ||= 'http://127.0.0.1:4001'
-
 require 'webmock/rspec'
 require 'etcd'
+require 'json'
+
+Dir["./spec/support/*.rb"].each { |f|  require f}

data/spec/support/client_helper.rb

@@ -0,0 +1,19 @@
+module ClientHelper
+  def default_client(uri = "http://127.0.0.1:4001")
+    client         = Etcd::Client.new(:uris => uri)
+    client.cluster = healthy_cluster(uri)
+    client
+  end
+
+  # manually construct a valid cluster object
+  # clumsy, but works atm
+  def healthy_cluster(uri = "http://127.0.0.1:4001")
+    data    = Etcd::Cluster.parse_cluster_status(status_data)
+    nodes   = Etcd::Cluster.nodes_from_attributes(data)
+    cluster = Etcd::Cluster.new(uri)
+    cluster.nodes = nodes
+    nodes.map{|x| x.status = :running}
+    nodes.first.is_leader = true
+    cluster
+  end
+end

data/spec/support/cluster_helper.rb

@@ -0,0 +1,75 @@
+module ClusterHelper
+  def status_data
+    [
+      {"action"=>"GET",
+      "key"=>"/_etcd/machines/node1",
+      "value"=>
+       "raft=http://127.0.0.1:7001&etcd=http://127.0.0.1:4001&raftVersion=v0.1.1",
+      "index"=>360},
+     {"action"=>"GET",
+      "key"=>"/_etcd/machines/node2",
+      "value"=>
+       "raft=http://127.0.0.1:7002&etcd=http://127.0.0.1:4002&raftVersion=v0.1.1",
+      "index"=>360},
+     {"action"=>"GET",
+      "key"=>"/_etcd/machines/node3",
+      "value"=>
+       "raft=http://127.0.0.1:7003&etcd=http://127.0.0.1:4003&raftVersion=v0.1.1",
+      "index"=>360}
+    ]
+  end
+
+  def healthy_cluster_config
+    {
+      'http://127.0.0.1:4001' => 'http://127.0.0.1:7001',
+      'http://127.0.0.1:4002' => 'http://127.0.0.1:7001',
+      'http://127.0.0.1:4003' => 'http://127.0.0.1:7001'
+    }
+  end
+
+  def one_down_cluster_config
+    {
+      'http://127.0.0.1:4001' => 'http://127.0.0.1:7001',
+      'http://127.0.0.1:4002' => 'http://127.0.0.1:7001',
+      'http://127.0.0.1:4003' => :down
+    }
+  end
+
+  def healthy_cluster_changed_leader_config
+    {
+      'http://127.0.0.1:4001' => 'http://127.0.0.1:7002',
+      'http://127.0.0.1:4002' => 'http://127.0.0.1:7002',
+      'http://127.0.0.1:4003' => 'http://127.0.0.1:7002'
+    }
+  end
+
+  def with_stubbed_status(uri)
+    status_uri = Etcd::Cluster.status_uri(uri)
+    stub_request(:get, status_uri).to_return(body: MultiJson.dump(status_data))
+    yield if block_given?
+    #WebMock.should have_requested(:get, status_uri)
+  end
+
+
+  def leader_uri(uri)
+    "#{uri}/v1/leader"
+  end
+
+  def stub_leader_uri(uri, opts = {})
+    leader = (opts[:leader] ||"http://127.0.0.1:7001")
+    if leader == :down
+      stub_request(:get, leader_uri(uri)).to_timeout
+    else
+      stub_request(:get, leader_uri(uri)).to_return(body: leader)
+    end
+  end
+
+  # [{etcd_url => leader_string},{etcd_url => leader_string}]
+  def with_stubbed_leaders(cluster_config)
+    cluster_config.each do |url, leader_uri|
+      stub_leader_uri(url, :leader => leader_uri)
+    end
+    yield if block_given?
+    #urls.each { |url| WebMock.should have_requested(:get, leader_uri(url))}
+  end
+end

data/spec/support/common_helper.rb

@@ -0,0 +1,13 @@
+require './spec/resources/cluster_controller'
+
+class Etcd::Client
+  def self.test_client(opts = {})
+    seed_uris = ["http://127.0.0.1:4001", "http://127.0.0.1:4002", "http://127.0.0.1:4003"]
+    opts.merge!(:uris => seed_uris)
+    begin
+      client = Etcd::Client.connect(opts)
+    rescue Etcd::AllNodesDownError
+      return nil
+    end
+  end
+end

metadata

@@ -1,48 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: etcd-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre1
-  prerelease: 6
+  version: 1.0.0
 platform: ruby
 authors:
 - Theo Hultberg
+- Roman Heinrich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-27 00:00:00.000000000 Z
+date: 2014-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.0
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: '1.7'
 description: ''
 email:
 - theo@iconara.net
@@ -50,40 +46,63 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
+- lib/etcd.rb
 - lib/etcd/client.rb
+- lib/etcd/client/failover.rb
+- lib/etcd/client/observing.rb
+- lib/etcd/client/protocol.rb
+- lib/etcd/cluster.rb
+- lib/etcd/constants.rb
+- lib/etcd/heartbeat.rb
+- lib/etcd/loggable.rb
+- lib/etcd/node.rb
+- lib/etcd/observer.rb
+- lib/etcd/requestable.rb
 - lib/etcd/version.rb
-- lib/etcd.rb
-- README.md
 - spec/etcd/client_spec.rb
+- spec/etcd/cluster_spec.rb
+- spec/etcd/node_spec.rb
+- spec/etcd/observer_spec.rb
 - spec/integration/etcd_spec.rb
+- spec/resources/cluster_controller.rb
 - spec/spec_helper.rb
+- spec/support/client_helper.rb
+- spec/support/cluster_helper.rb
+- spec/support/common_helper.rb
 homepage: http://github.com/iconara/etcd-rb
 licenses:
 - Apache License 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ''
 test_files:
 - spec/etcd/client_spec.rb
+- spec/etcd/cluster_spec.rb
+- spec/etcd/node_spec.rb
+- spec/etcd/observer_spec.rb
 - spec/integration/etcd_spec.rb
+- spec/resources/cluster_controller.rb
 - spec/spec_helper.rb
+- spec/support/client_helper.rb
+- spec/support/cluster_helper.rb
+- spec/support/common_helper.rb
 has_rdoc: