etcd 0.0.6 → 0.2.0.alpha

data/lib/etcd/log.rb

@@ -0,0 +1,10 @@
+# Encoding: utf-8
+
+require 'mixlib/log'
+module Etcd
+  ##
+  # A wrapper class that extends Mixlib::Log
+  class Log
+    extend Mixlib::Log
+  end
+end

data/lib/etcd/mod/leader.rb

@@ -0,0 +1,28 @@
+# Encoding: utf-8
+
+require 'timeout'
+
+module Etcd
+  module Mod
+    module Leader
+
+      def mod_leader_endpoint
+        '/mod/v2/leader'
+      end
+
+      def set_leader(key, value, ttl)
+        path = mod_leader_endpoint + "#{key}?ttl=#{ttl}"
+        api_execute(path, :put, params:{name: value}).body
+      end
+
+      def get_leader(key)
+        api_execute(mod_leader_endpoint + key, :get).body
+      end
+
+      def delete_leader(key, value)
+        path = mod_leader_endpoint + key + '?' + URI.encode_www_form(name: value)
+        api_execute(path, :delete).body
+      end
+    end
+  end
+end

data/lib/etcd/mod/lock.rb

@@ -0,0 +1,59 @@
+# Encoding: utf-8
+
+require 'timeout'
+
+module Etcd
+  module Mod
+    module Lock
+
+      def mod_lock_endpoint
+        '/mod/v2/lock'
+      end
+
+      def acquire_lock(key, ttl, opts={})
+        path = mod_lock_endpoint + key + "?ttl=#{ttl}"
+        timeout = opts[:timeout] || 60
+        Timeout::timeout(timeout) do
+          api_execute(path, :post, params:opts)
+        end
+      end
+
+      def renew_lock(key, ttl, opts={})
+        unless opts.has_key?(:index) or opts.has_key?(:value)
+          raise ArgumentError, 'You mast pass index or value'
+        end
+        path = mod_lock_endpoint + key + "?ttl=#{ttl}"
+        timeout = opts[:timeout] || 60
+        Timeout::timeout(timeout) do
+          api_execute(path, :put, params:opts).body
+        end
+      end
+
+      def get_lock(key, opts={})
+        api_execute(mod_lock_endpoint + key, :get, params:opts).body
+      end
+
+      def delete_lock(key, opts={})
+        unless opts.has_key?(:index) or opts.has_key?(:value)
+          raise ArgumentError, 'You must pass index or value'
+        end
+        api_execute(mod_lock_endpoint + key, :delete, params:opts)
+      end
+
+      def lock(key, ttl, opts={})
+        acquire_lock('/'+key, ttl, opts)
+        index= get_lock('/'+key, field: index)
+        begin
+          yield key
+        rescue Exception => e
+          raise e
+        ensure
+          delete_lock(key, index: index)
+        end
+      end
+
+      alias_method :retrive_lock, :get_lock
+      alias_method :release_lock, :delete_lock
+    end
+  end
+end

data/lib/etcd/node.rb

@@ -0,0 +1,44 @@
+# Encoding: utf-8
+
+module Etcd
+  class Node
+
+    include Comparable
+
+    attr_reader :created_index, :modified_index, :expiration, :ttl, :key, :value
+    alias :createdIndex :created_index
+    alias :modifiedIndex :modified_index
+
+    def initialize(opts={})
+      @created_index = opts['createdIndex']
+      @modified_index = opts['modifiedIndex']
+      @ttl = opts['ttl']
+      @key = opts['key']
+      @value = opts['value']
+      @expiration = opts['expiration']
+      @dir = opts['dir']
+
+      if opts['dir'] and (!!opts['nodes'])
+        opts['nodes'].each do |data|
+          children << Node.new(data)
+        end
+      end
+    end
+
+    def <=>(other)
+      key <=> other.key
+    end
+
+    def children
+      if directory?
+        @children ||= []
+      else
+        raise "This is not a directory, cant have children"
+      end
+    end
+
+    def directory?
+      !! @dir
+    end
+  end
+end

data/lib/etcd/response.rb

@@ -0,0 +1,33 @@
+# Encoding: utf-8
+
+require 'etcd/node'
+require 'json'
+
+module Etcd
+
+  class Response
+
+    extend Forwardable
+
+    attr_reader :action, :node, :etcd_index, :raft_index, :raft_term
+
+    def_delegators :@node, :key, :value, :directory?, :children
+
+    def initialize(opts, headers={})
+      @action = opts['action']
+      @node = Node.new(opts['node'])
+      @etcd_index = headers[:etcd_index]
+      @raft_index = headers[:raft_index]
+      @raft_term = headers[:raft_term]
+    end
+
+    def self.from_http_response(response)
+      data = JSON.parse(response.body)
+      headers = Hash.new
+      headers[:etcd_index] = response['X-Etcd-Index'].to_i
+      headers[:raft_index] = response['X-Raft-Index'].to_i
+      headers[:raft_term] = response['X-Raft-Term'].to_i
+      response = Response.new(data, headers)
+    end
+  end
+end

data/lib/etcd/stats.rb

@@ -0,0 +1,25 @@
+# Encoding: utf-8
+
+require 'json'
+
+module Etcd
+  module Stats
+
+    def stats_endpoint
+      version_prefix + '/stats'
+    end
+
+    def stats(type)
+      case type
+      when :leader
+        JSON.parse(api_execute(stats_endpoint+'/leader', :get).body)
+      when :store
+        JSON.parse(api_execute(stats_endpoint+'/store', :get).body)
+      when :self
+        JSON.parse(api_execute(stats_endpoint+'/self', :get).body)
+      else
+        raise ArgumentError, "Invalid stats type '#{type}'"
+      end
+    end
+  end
+end

data/lib/etcd/version.rb

@@ -0,0 +1,5 @@
+# Encoding: utf-8
+
+module Etcd
+  VERSION = "0.2.0.alpha"
+end

data/spec/etcd/client_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Etcd::Client do
+
+  let(:client) do
+    Etcd.client
+  end
+
+  it 'should return the leader address' do
+    expect(client.leader).to_not be_nil
+  end
+
+  it '#machines' do
+    expect(client.machines).to include('http://127.0.0.1:4001')
+  end
+
+  it '#version' do
+    expect(client.version).to match(/^etcd v0\.2\./)
+  end
+
+  it '#version_prefix' do
+    expect(client.version_prefix).to eq('/v2')
+  end
+
+  context '#api_execute' do
+    it 'should raise exception when non http methods are passed' do
+      expect do
+        client.api_execute('/v2/keys/x', :do)
+      end.to raise_error
+    end
+
+    it 'should redirect api request when allo_redirect is set'
+  end
+
+  context '#http header based metadata' do
+    before(:all) do
+      key = random_key
+      value = uuid.generate
+      @response = Etcd.client.set(key,value)
+    end
+
+    it '#etcd_index' do
+      expect(@response.etcd_index).to_not be_nil
+    end
+
+    it '#raft_index' do
+      expect(@response.raft_index).to_not be_nil
+    end
+
+    it '#raft_term' do
+      expect(@response.raft_term).to_not be_nil
+    end
+  end
+end

data/spec/etcd/keys_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Etcd::Keys do
+
+  let(:client) do
+    Etcd.client
+  end
+
+  it '#set/#get' do
+    key = random_key
+    value = uuid.generate
+    client.set(key, value)
+    expect(client.get(key).value).to eq(value)
+  end
+
+  context '#exists?' do
+    it 'should be true for existing keys' do
+      key = random_key
+      client.create(key, 10)
+      expect(client.exists?(key)).to be_true
+    end
+    it 'should be true for existing keys' do
+      expect(client.exists?(random_key)).to be_false
+    end
+  end
+end

data/spec/etcd/leader_spec.rb

@@ -0,0 +1,29 @@
+# Encoding: utf-8
+
+require 'spec_helper'
+
+describe 'mod leader' do
+
+  let(:client) do
+    Etcd.client
+  end
+
+  it 'should allow setting a key value with ttl' do
+    client.set_leader('/db_master1', 'db01', 10)
+    expect(client.get_leader('/db_master1')).to eq('db01')
+  end
+
+  it 'should allow deleting key with value' do
+    client.set_leader('/db_master4', 'db04', 10)
+    expect do
+      client.delete_leader('/db_master4', 'db04')
+    end.to_not raise_error
+  end
+
+  it 'should not allow deleting key without value' do
+    client.set_leader('/db_master5', 'db05', 10)
+    expect do
+      client.delete_leader('/db_master5', 'db04')
+    end.to raise_error
+  end
+end

data/spec/etcd/lock_spec.rb

@@ -0,0 +1,46 @@
+# Encoding: utf-8
+
+require 'spec_helper'
+
+describe 'lock' do
+
+  let(:client) do
+    Etcd.client
+  end
+
+  it 'should be able to acquire a lock' do
+    expect do
+      client.acquire_lock('/my_lock',10)
+    end.to_not raise_error
+  end
+
+  it 'should be able to renew a lock based on value' do
+    client.acquire_lock('/my_lock1', 10, value: 123)
+    expect do
+      client.renew_lock('/my_lock1', 10, value: 123)
+    end.to_not raise_error
+  end
+
+  it 'should be able to renew a lock based on index' do
+    client.acquire_lock('/my_lock2', 10)
+    index = client.get_lock('/my_lock2', field:'index')
+    expect do
+      client.renew_lock('/my_lock2', 10, index: index)
+    end.to_not raise_error
+  end
+
+  it 'should be able to delete a lock based on value' do
+    client.acquire_lock('/my_lock3', 10, value: 123)
+    expect do
+      client.delete_lock('/my_lock3', value: 123)
+    end.to_not raise_error
+  end
+
+  it 'should be able to delete a lock based on index' do
+    client.acquire_lock('/my_lock4', 10)
+    index = client.get_lock('/my_lock4', field:'index')
+    expect do
+      client.delete_lock('/my_lock4', index: index)
+    end.to_not raise_error
+  end
+end

data/spec/etcd/node_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Etcd::Node do
+
+  let(:client) do
+    Etcd.client
+  end
+
+  it "should create a directory with parent key when nested keys are set" do
+    parent = random_key
+    child = random_key
+    value = uuid.generate
+    client.set(parent+child, value)
+    expect(client.get(parent+child)).to_not be_directory
+    expect(client.get(parent)).to be_directory
+  end
+
+  context '#children' do
+    it 'should raise exception when invoked against a leaf node' do
+      parent = random_key
+      client.create(random_key, 10)
+      expect do
+        client.get(random_key).children
+      end.to raise_error
+    end
+  end
+end

data/spec/{functional → etcd}/read_only_client_spec.rb

@@ -1,4 +1,13 @@
-shared_examples "read only client" do
+# Encoding: utf-8
+
+require 'spec_helper'
+
+describe "Etcd read only client" do
+
+  let(:client) do
+    Etcd.client
+  end
+
   it "should not allow write" do
     key= random_key
     expect{
@@ -17,7 +26,7 @@ shared_examples "read only client" do
   it "should allow watch" do
     key = random_key
     value = uuid.generate
-    index = client.set(key, value).index
+    index = client.set(key, value).node.modified_index
     expect(read_only_client.watch(key, index: index).value).to eq(value)
   end
 end

data/spec/etcd/readme_spec.rb

@@ -0,0 +1,312 @@
+# Encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Etcd specs for the main etcd README examples' do
+
+  let(:client) do
+    Etcd.client
+  end
+
+  shared_examples 'response with valid node data' do |action|
+    if action == :delete
+      it 'should not have value' do
+        expect(@response.node.value).to be_nil
+      end
+    else
+      it 'should set the value correctly' do
+        expect(@response.node.value).to eq('PinkFloyd')
+      end
+    end
+    if action == :create
+      it 'should set the parent key correctly' do
+        expect(@response.node.key).to match /^\/queue\/+/
+      end
+    else
+      it 'should set the key properly' do
+        expect(@response.node.key).to eq('/message')
+      end
+    end
+
+    it 'modified index should be a positive integer' do
+      expect(@response.node.created_index).to be > 0
+    end
+
+    it 'created index should be a positive integer' do
+      expect(@response.node.modified_index).to be > 0
+    end
+  end
+
+  shared_examples 'response with valid http headers' do
+
+    it 'should have a positive etcd index (comes from http header)' do
+      expect(@response.etcd_index).to be > 0
+    end
+
+    it 'should have a positive raft index (comes from http header)' do
+      expect(@response.raft_index).to be > 0
+    end
+
+    it 'should have a positive raft term (comes from http header)' do
+      expect(@response.raft_term).to be >= 0
+    end
+  end
+
+  context 'set a key named "/message"' do
+    
+
+    before(:all) do
+     @response = Etcd.client.set('/message', 'PinkFloyd')
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data'
+
+    it 'should set the return action to SET' do
+      expect(@response.action).to eq('set')
+    end
+  end
+
+  context 'get a key named "/message"' do
+
+    before(:all) do
+      Etcd.client.set('/message', 'PinkFloyd')
+      @response = Etcd.client.get('/message')
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data'
+
+    it 'should set the return action to GET' do
+      expect(@response.action).to eq('get')
+    end
+  end
+
+  context 'change the value of a key named "/message"' do
+
+    before(:all) do
+      Etcd.client.set('/message', 'World')
+      @response = Etcd.client.set('/message','PinkFloyd')
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data'
+
+    it 'should set the return action to SET' do
+      expect(@response.action).to eq('set')
+    end
+  end
+
+  context 'delete a key named "/message"' do
+
+    before(:all) do
+      Etcd.client.set('/message', 'World')
+      Etcd.client.set('/message','PinkFloyd')
+      @response = Etcd.client.delete('/message')
+    end
+
+    it 'should set the return action to SET' do
+      expect(@response.action).to eq('delete')
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data', :delete
+  end
+
+  context 'using ttl a key named "/message"' do
+
+    before(:all) do
+      Etcd.client.set('/message', 'World')
+      @set_time = Time.now
+      @response = Etcd.client.set('/message','PinkFloyd', 5)
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data'
+
+    it 'should set the return action to SET' do
+      expect(@response.action).to eq('set')
+    end
+
+    it 'should have valid expiration time' do
+      expect(@response.node.expiration).to_not be_nil
+    end
+
+    it 'should have ttl available from the node' do
+      expect(@response.node.ttl).to eq(5)
+    end
+
+    it 'should throw exception after the expiration time' do
+      sleep 8
+      expect do
+        Etcd.client.get('/message')
+      end.to raise_error
+    end
+
+  end
+
+  context 'waiting for a change against a key named "/message"' do
+
+    before(:all) do
+      Etcd.client.set('/message', 'foo')
+      thr = Thread.new do
+        @response = Etcd.client.watch('/message')
+      end
+      Etcd.client.set('/message', 'PinkFloyd')
+      thr.join
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data'
+
+    it 'should set the return action to SET' do
+      expect(@response.action).to eq('set')
+    end
+
+    it 'should get the exact value by specifying a waitIndex' do
+      client.set('/message', 'someshit')
+      w_response = client.watch('/message', index: @response.node.modified_index)
+      expect(w_response.node.value).to eq('PinkFloyd')
+    end
+  end
+
+  context 'atomic in-order keys' do
+
+    before(:all) do
+      @response = Etcd.client.create_in_order('/queue', 'PinkFloyd')
+    end
+
+    it_should_behave_like 'response with valid http headers'
+    it_should_behave_like 'response with valid node data', :create
+
+    it 'should set the return action to create' do
+      expect(@response.action).to eq('create')
+    end
+
+    it 'should have the child key as a positive integer' do
+      expect(@response.key.split('/').last.to_i).to be > 0
+    end
+
+    it 'should have the child keys as monotonically increasing' do
+      first_response = client.create_in_order('/queue', 'The Jimi Hendrix Experience')
+      second_response = client.create_in_order('/queue', 'The Doors')
+      first_key = first_response.key.split('/').last.to_i
+      second_key = second_response.key.split('/').last.to_i
+      expect(first_key).to be < second_key
+    end
+
+    it 'should enlist all children in sorted manner' do
+      responses = []
+      10.times do |n|
+        responses << client.create_in_order('/queue', 'Deep Purple - Track #{n}')
+      end
+      directory = client.get('/queue', sorted: true)
+      past_index = directory.children.index(responses.first.node)
+      9.times do |n|
+        current_index = directory.children.index(responses[n+1].node)
+        expect(current_index).to be > past_index
+        past_index = current_index
+      end
+    end
+  end
+
+  context 'directory with ttl' do
+
+    before(:all) do
+      @response = Etcd.client.set('/directory', dir: true, ttl: 4)
+    end
+
+    it 'should create a directory' do
+      expect(client.get('/directory')).to be_directory
+    end
+
+    it 'should have valid expiration time' do
+      expect(client.get('/directory').node.expiration).to_not be_nil
+    end
+
+    it 'should have pre-designated ttl' do
+      expect(client.get('/directory').node.ttl).to eq(4)
+    end
+
+    it 'will throw error if updated without setting prevExist' do
+      expect do
+        client.set('/directory', dir:true, ttl:5)
+      end.to raise_error
+    end
+
+    it 'can be updated by setting  prevExist to true' do
+      client.set('/directory', prevExist: true, dir:true, ttl:5)
+      expect(client.get('/directory').node.ttl).to eq(5)
+    end
+
+    it 'watchers should get expriy notification' do
+      client.set('/directory/a', 'Test')
+      client.set('/directory', prevExist: true, dir:true, ttl:2)
+      response = client.watch('/directory/a', consistent: true, timeout: 3)
+      expect(response.action).to eq('expire')
+    end
+    it 'should be expired after ttl' do
+      sleep 5
+      expect do
+        client.get('/directory')
+      end.to raise_error
+    end
+  end
+
+  context 'atomic compare and swap' do
+
+    it 'should  raise error if prevExist is passed a false' do
+      client.set('/foo', 'one')
+      expect do
+        client.set('/foo','three', prevExist: false)
+      end.to raise_error
+    end
+
+    it 'should raise error is prevValue is wrong' do
+      client.set('/foo', 'one')
+      expect do
+        client.set('/foo','three', prevValue: 'two')
+      end.to raise_error
+    end
+
+    it 'should allow setting the value when prevValue is right' do
+      client.set('/foo', 'one')
+      expect(client.set('/foo','three', prevValue: 'one').value).to eq('three')
+    end
+  end
+  context 'directory manipulation' do
+    it 'should allow creating directory' do
+      expect(client.set('/dir',dir:true)).to be_directory
+    end
+
+    it 'should allow listing directory' do
+      client.set('/foo_dir/foo','bar')
+      expect(client.get('/').children.map(&:key)).to include('/foo_dir')
+    end
+
+    it 'should allow recursive directory listing' do
+      response = client.get('/', recursive: true)
+      expect(response.children.find{|n|n.key=='/foo_dir'}.children).to_not be_empty
+    end
+
+    it 'should be able to delete empty directory without the recusrive flag' do
+      expect(client.delete('/dir', dir: true).action).to eq('delete')
+    end
+
+    it 'should be able to delete directory with children with the recusrive flag' do
+      expect(client.delete('/foo_dir', recursive: true).action).to eq('delete')
+    end
+  end
+
+  context 'hidden nodes' do
+
+    before(:all) do
+      Etcd.client.set('/_message', 'Hello Hidden World')
+      Etcd.client.set('/message', 'Hello World')
+    end
+
+    it 'should not be visible in directory listing' do
+      expect(client.get('/').children.map(&:key)).to_not include('_message')
+    end
+  end
+end