etcd 0.2.0.alpha → 0.2.0.beta.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjEwNDYyYjk0OWMyNzU2M2NhMjk2N2QxYmVmYTFhMmI2NjhlNzdiOQ==
+    YjhkNjNmODJjMmU3YTg3NDliYTU4ODk3MjY0NDYyYjNjODg1Y2QwZg==
   data.tar.gz: !binary |-
-    NDdkYzdhMzM4ZmFhZWU1YTkxZTM3ZWEwYTA1MDE1YjI5NWZmODgxZg==
+    NzEyZjMxMTcwYmFiOWY3ZWU0OTg0YzdiMDFlNTNlNGJiM2Q2NjAwNw==
 SHA512:
   metadata.gz: !binary |-
-    OGI3MTA1YmM5MjA4ZjUzYmE4Mjc0MTVmYWEzODU1NDI0ZjhiMzNlZDM3MWQ1
-    Mjk1NTIxNmY2MzA4MGYyZTEyZTRiZjExOTFiZTRkNGI3MzAyZjFkOWY3Yjdm
-    MGY5NGNmYjU5NDEwOTVjZDNjMzBiOWU5YTA5YzNmOTUwNGEzMDA=
+    YTM3YWI4NDQ1YWJhY2E1NjgwYmJlMjkyNGZiYmQ4YWNmYjQ3NDlmNDlmNGIy
+    ZjUwYTA0MWNjMGVkZWE1Y2Y3MTliNWNjYzMzODc5YzQwNjA2YzVhNzVhMDRh
+    MTk4MDYxYWI0NjAwYzEyYTVhYzc3YzI3ZDM2YmI3OWVkMWJlZjU=
   data.tar.gz: !binary |-
-    OGYwZThkZjFmMDcxNzUyZTBjODBhMTgwZWYwMWVmZjU1NzAyZmVjNTg5YmY5
-    ZGQ0ODgxYmMzNjBlMTFmMDZhOTI3MmI2MTgzMGE0NDQ3ODkxYWIzYWI0NDc0
-    YzAzNzNjYzc3YzIwYzZiMGI5ZjEzN2ZjMWI5NmFlMDkzNDNlOWM=
+    YWUwNGJkYWIwOWZkOGVkMDRlNDg5NmQ1MzY5NWI1OGI1MGI3MjNjODc3ODNh
+    NzBhNjc2YzI2ZGI1ZDAzMGU1MDYzMmNjNDAxZTFkYjkzZTZlYmNiYjJlNDkz
+    N2ZkNDk5NTcyMGIyZDM0OTlkNDMxZDJkOGFiNzc1OGI5ZThlNmI=

data/.rspec

@@ -1,2 +1,3 @@
 -c
--fs
+-fd
+--fail-fast

data/.rubocop.yml

@@ -0,0 +1,12 @@
+AllCops:
+  Includes:
+    - Gemfile
+    - lib/**
+  Excludes:
+    - spec/**
+
+Encoding:
+  Enabled: false
+
+LineLength:
+  Max: 100

data/.travis.yml

@@ -8,4 +8,4 @@ rvm:
 branches:
   only:
     - master
-script: "bundle exec rake spec"
+script: "ETCD_BIN=./etcd/bin/etcd bundle exec rake spec"

data/Gemfile

@@ -2,5 +2,10 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in etcd.gemspec
 gemspec
+
 gem 'coco'
 gem 'rubocop'
+gem 'guard'
+gem 'guard-rake'
+# uuid gem isn't pulling in systemu
+gem 'systemu'

data/Guardfile

@@ -0,0 +1,9 @@
+# vim: set ft=ruby:
+require 'guard/guard'
+require 'guard/rake'
+
+guard 'rake', :task => 'test:quick' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -22,6 +22,7 @@ Or install it yourself as:
 client = Etcd.client # this will create a client against etcd server running on localhost on port 4001
 client = Etcd.client(port: 4002)
 client = Etcd.client(host: '127.0.0.1', port: 4003)
+client = Etcd.client(:user_name => 'test', :password => 'pwd') # populates the authentication header for basic HTTP auth with user name and password (useful for proxied connections)
 client = Etcd.client(host: '127.0.0.1', port: 4003, allow_redirect: false) # wont let you run sensitive commands on non-leader machines, default is true
 ```
 ### Set a key
@@ -66,11 +67,14 @@ client.machines
 ```ruby
 client.leader
 ```
+More examples and api details can be found in the [wiki](https://github.com/ranjib/etcd-ruby/wiki)
 
 ## Contributors 
 * Ranjib Dey
-* Jesse Nelson
-
+* [Jesse Nelson](https://github.com/spheromak)
+* [Nilesh Bairagi](https://github.com/Bairagi)
+* [Dr Nic Williams](https://github.com/drnic)
+* [Eric Buth] (https://github.com/buth)
 
 
 ## Contributing

data/Rakefile

@@ -1,10 +1,23 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 require "rdoc/task"
+require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new("spec")
 
+Rubocop::RakeTask.new do |task|
+  task.fail_on_error = true
+end
+
 RDoc::Task.new do |rdoc|
   rdoc.main = "README.rdoc"
   rdoc.rdoc_files.include("lib   /*.rb")
 end
+
+namespace :test do
+  desc 'Run all of the quick tests.'
+  task :quick do
+    Rake::Task['rubocop'].invoke
+    Rake::Task['spec'].invoke
+  end
+end

data/lib/etcd.rb

@@ -2,7 +2,7 @@
 
 require 'etcd/client'
 ##
-# This module provides the Etcd:: name space for the gem and few 
+# This module provides the Etcd:: name space for the gem and few
 # factory methods for Etcd domain objects
 module Etcd
   ##
@@ -10,7 +10,7 @@ module Etcd
   # as an argument which gets passed to the Etcd::Client.new method
   # directly
   # If +opts+ is not passed default options are used, defined by Etcd::Client.new
-  def self.client(opts={})
+  def self.client(opts = {})
     Etcd::Client.new(opts)
   end
 end

data/lib/etcd/client.rb

@@ -1,5 +1,6 @@
 # Encoding: utf-8
 
+require 'openssl'
 require 'net/http'
 require 'json'
 require 'etcd/log'
@@ -16,10 +17,9 @@ module Etcd
   # etcd api, like Etcd::Client#lock and Etcd::Client#eternal_watch, they
   # are defined in separate modules and included in this class
   class Client
-
-    HTTP_REDIRECT = ->(r){ r.is_a? Net::HTTPRedirection }
-    HTTP_SUCCESS = ->(r){ r.is_a? Net::HTTPSuccess }
-    HTTP_CLIENT_ERROR = ->(r){ r.is_a? Net::HTTPClientError }
+    HTTP_REDIRECT = ->(r) { r.is_a? Net::HTTPRedirection }
+    HTTP_SUCCESS = ->(r) { r.is_a? Net::HTTPSuccess }
+    HTTP_CLIENT_ERROR = ->(r) { r.is_a? Net::HTTPClientError }
 
     include Stats
     include Keys
@@ -28,6 +28,7 @@ module Etcd
 
     attr_reader :host, :port, :http, :allow_redirect
     attr_reader :use_ssl, :verify_mode, :read_timeout
+    attr_reader :user_name, :password
 
     ##
     # Creates an Etcd::Client object. It accepts a hash +opts+ as argument
@@ -36,6 +37,7 @@ module Etcd
     # @opts [String] :host IP address of the etcd server (default 127.0.0.1)
     # @opts [Fixnum] :port Port number of the etcd server (default 4001)
     # @opts [Fixnum] :read_timeout set HTTP read timeouts (default 60)
+    # rubocop:disable CyclomaticComplexity
     def initialize(opts = {})
       @host = opts[:host] || '127.0.0.1'
       @port = opts[:port] || 4001
@@ -43,7 +45,10 @@ module Etcd
       @allow_redirect = opts.key?(:allow_redirect) ? opts[:allow_redirect] : true
       @use_ssl = opts[:use_ssl] || false
       @verify_mode = opts.key?(:verify_mode) ? opts[:verify_mode] : OpenSSL::SSL::VERIFY_PEER
+      @user_name = opts[:user_name] || nil
+      @password = opts[:password] || nil
     end
+    # rubocop:enable CyclomaticComplexity
 
     # Returns the etcd api version that will be used for across API methods
     def version_prefix
@@ -71,6 +76,7 @@ module Etcd
     # * path    - etcd server path (etcd server end point)
     # * method  - the request method used
     # * options  - any additional parameters used by request method (optional)
+    # rubocop:disable MethodLength, CyclomaticComplexity
     def api_execute(path, method, options = {})
       params = options[:params]
       case  method
@@ -90,21 +96,26 @@ module Etcd
       http.read_timeout = timeout
       http.use_ssl = use_ssl
       http.verify_mode = verify_mode
+      req.basic_auth(user_name, password) if [user_name, password].all?
       Log.debug("Invoking: '#{req.class}' against '#{path}")
       res = http.request(req)
       Log.debug("Response code: #{res.code}")
-      process_http_request(res)
+      process_http_request(res, req, params)
     end
 
-    def process_http_request(res)
+    # need to ahve original request to process the response when it redirects
+    def process_http_request(res, req = nil, params = nil)
       case res
       when HTTP_SUCCESS
         Log.debug('Http success')
         res
       when HTTP_REDIRECT
         if allow_redirect
-          Log.debug('Http redirect, following')
-          api_execute(res['location'], method, params: params)
+          uri = URI(res['location'])
+          @host = uri.host
+          @port = uri.port
+          Log.debug("Http redirect, setting new host to: #{@host}:#{@port}, and retrying")
+          api_execute(uri.path, req.method.downcase.to_sym, params: params)
         else
           Log.debug('Http redirect not allowed')
           res.error!
@@ -117,6 +128,7 @@ module Etcd
         res.error!
       end
     end
+    # rubocop:enable MethodLength
 
     def build_http_request(klass, path, params = nil, body = nil)
       path += '?' + URI.encode_www_form(params) unless params.nil?

data/lib/etcd/exceptions.rb

@@ -36,6 +36,7 @@ module Etcd
   class NotDir < Error; end
   class NodeExist < Error; end
   class KeyIsPreserved < Error; end
+  class DirNotEmpty < Error; end
 
   # Post form related error
   class ValueRequired < Error; end
@@ -60,6 +61,7 @@ module Etcd
     104 => NotDir,
     105 => NodeExist,
     106 => KeyIsPreserved,
+    108 => DirNotEmpty,
 
     # Post form related error
     200 => ValueRequired,

data/lib/etcd/keys.rb

@@ -16,8 +16,8 @@ module Etcd
     # Retrives a key with its associated data, if key is not present it will
     # return with message "Key Not Found"
     #
-    # This method has following parameters as argument
-    # * key - whose data to be retrive
+    # This method takes the following parameters as arguments
+    # * key - whose data is to be retrieved
     def get(key, opts = {})
       response = api_execute(key_endpoint + key, :get, params: opts)
       Response.from_http_response(response)
@@ -25,30 +25,16 @@ module Etcd
 
     # Create or update a new key
     #
-    # This method has following parameters as argument
+    # This method takes the following parameters as arguments
     # * key   - whose value to be set
     # * value - value to be set for specified key
-    # * ttl   - shelf life of a key (in secsonds) (optional)
-    def set(key, value, opts = nil)
+    # * ttl   - shelf life of a key (in seconds) (optional)
+    def set(key, opts = nil)
+      fail ArgumentError, 'Second argument must be a hash' unless opts.is_a?(Hash)
       path  = key_endpoint + key
       payload = {}
-      if value.is_a?(Hash) # directory
-        opts = value.dup
-      else
-        payload['value'] = value
-      end
-      if opts.is_a? Fixnum
-        warn '[DEPRECATION] Passing ttl as raw argument is deprecated \
-        please use :ttl => value, this will be removed in next minor release'
-        payload['ttl'] = opts
-      elsif opts.is_a? Hash
-        [:ttl, :dir, :prevExist, :prevValue, :prevIndex].each do |k|
-          payload[k] = opts[k] if opts.key?(k)
-        end
-      elsif opts.nil?
-        # do nothing
-      else
-        fail ArgumentError, "Dont know how to parse #{opts}"
+      [:ttl, :value, :dir, :prevExist, :prevValue, :prevIndex].each do |k|
+        payload[k] = opts[k] if opts.key?(k)
       end
       response = api_execute(path, :put, params: payload)
       Response.from_http_response(response)
@@ -56,7 +42,7 @@ module Etcd
 
     # Deletes a key (and its content)
     #
-    # This method has following parameters as argument
+    # This method takes the following parameters as arguments
     # * key - key to be deleted
     def delete(key, opts = {})
       response = api_execute(key_endpoint + key, :delete, params: opts)
@@ -65,71 +51,63 @@ module Etcd
 
     # Set a new value for key if previous value of key is matched
     #
-    # This method takes following parameters as argument
+    # This method takes the following parameters as arguments
     # * key       - whose value is going to change if previous value is matched
     # * value     - new value to be set for specified key
     # * prevValue - value of a key to compare with existing value of key
     # * ttl       - shelf life of a key (in secsonds) (optional)
-    def compare_and_swap(key, value, prevValue, ttl = nil)
-      path  = key_endpoint + key
-      payload = { 'value' => value, 'prevValue' => prevValue }
-      payload['ttl'] = ttl unless ttl.nil?
-      response = api_execute(path, :put, params: payload)
-      Response.from_http_response(response)
+    def compare_and_swap(key, opts =  {})
+      fail ArgumentError, 'Second argument must be a hash' unless opts.is_a?(Hash)
+      fail ArgumentError, 'You must pass prevValue' unless opts.key?(:prevValue)
+      set(key, opts)
     end
 
     # Gives a notification when specified key changes
     #
-    # This method has following parameters as argument
+    # This method takes the following parameters as arguments
     # @ key   - key to be watched
     # @options [Hash] additional options for watching a key
     # @options [Fixnum] :index watch the specified key from given index
     # @options [Fixnum] :timeout specify http timeout
-    def watch(key, options = {})
+    def watch(key, opts = {})
       params = { wait: true }
-      timeout = options[:timeout] || @read_timeout
-      index = options[:waitIndex] || options[:index]
+      fail ArgumentError, 'Second argument must be a hash' unless opts.is_a?(Hash)
+      timeout = opts[:timeout] || @read_timeout
+      index = opts[:waitIndex] || opts[:index]
       params[:waitIndex] = index unless index.nil?
-      params[:consistent] = options[:consistent] if options.key?(:consistent)
+      params[:consistent] = opts[:consistent] if opts.key?(:consistent)
 
       response = api_execute(key_endpoint + key, :get,
                              timeout: timeout, params: params)
       Response.from_http_response(response)
     end
 
-    def create_in_order(dir, value, opts = {})
+    def create_in_order(dir, opts = {})
       path  = key_endpoint + dir
-      payload = { 'value' => value }
-      payload['ttl'] = opts[:ttl] if opts[:ttl]
+      fail ArgumentError, 'Second argument must be a hash' unless opts.is_a?(Hash)
+      payload = {}
+      [:ttl, :value].each do |k|
+        payload[k] = opts[k] if opts.key?(k)
+      end
       response = api_execute(path, :post, params: payload)
       Response.from_http_response(response)
     end
 
     def exists?(key)
-      begin
-        Etcd::Log.debug("Checking if key:' #{key}' exists")
-        get(key)
-        true
-      rescue KeyNotFound => e
-        Etcd::Log.debug("Key does not exist #{e}")
-        false
-      end
+      Etcd::Log.debug("Checking if key:' #{key}' exists")
+      get(key)
+      true
+    rescue KeyNotFound => e
+      Etcd::Log.debug("Key does not exist #{e}")
+      false
     end
 
-    def create(key, value, ttl = nil)
-      path  = key_endpoint + key
-      payload = { value: value, prevExist: false }
-      payload['ttl'] = ttl unless ttl.nil?
-      response = api_execute(path, :put, params: payload)
-      Response.from_http_response(response)
+    def create(key, opts = {})
+      set(key, opts.merge(prevExist: false))
     end
 
-    def update(key, value, ttl = nil)
-      path  = key_endpoint + key
-      payload = { value: value, prevExist: true }
-      payload['ttl'] = ttl unless ttl.nil?
-      response = api_execute(path, :put, params: payload)
-      Response.from_http_response(response)
+    def update(key, opts = {})
+      set(key, opts.merge(prevExist: true))
     end
 
     def eternal_watch(key, index = nil)

data/lib/etcd/mod/leader.rb

@@ -4,15 +4,15 @@ require 'timeout'
 
 module Etcd
   module Mod
+    # Implemetn Etcd's Leader module
     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
+        api_execute(path, :put, params: { name: value }).body
       end
 
       def get_leader(key)

data/lib/etcd/mod/lock.rb

@@ -4,45 +4,46 @@ require 'timeout'
 
 module Etcd
   module Mod
+    # implement etcd lock module
     module Lock
-
       def mod_lock_endpoint
         '/mod/v2/lock'
       end
 
-      def acquire_lock(key, ttl, opts={})
+      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)
+        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'
+      def renew_lock(key, ttl, opts = {})
+        unless opts.key?(:index) || opts.key?(:value)
+          fail 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
+        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
+      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'
+      def delete_lock(key, opts = {})
+        unless opts.key?(:index) || opts.key?(:value)
+          fail ArgumentError, 'You must pass index or value'
         end
-        api_execute(mod_lock_endpoint + key, :delete, params:opts)
+        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)
+      # rubocop:disable RescueException
+      def lock(key, ttl, opts = {})
+        acquire_lock('/' + key, ttl, opts)
+        index = get_lock('/' + key, field: index)
         begin
           yield key
         rescue Exception => e
@@ -51,6 +52,7 @@ module Etcd
           delete_lock(key, index: index)
         end
       end
+      # rubocop:enable RescueException
 
       alias_method :retrive_lock, :get_lock
       alias_method :release_lock, :delete_lock