etcd 0.0.6 → 0.2.0.alpha

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 1b268d252f6591fe8015fcf257369ec0502d62b2
-  data.tar.gz: 0b2567328a06ca5f6433948c7431ee7c4bb4a2d8
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjEwNDYyYjk0OWMyNzU2M2NhMjk2N2QxYmVmYTFhMmI2NjhlNzdiOQ==
+  data.tar.gz: !binary |-
+    NDdkYzdhMzM4ZmFhZWU1YTkxZTM3ZWEwYTA1MDE1YjI5NWZmODgxZg==
 SHA512:
-  metadata.gz: 9925238076f679e9983358c87f24d53e4f95726bfdea41f06aae831277f5126a99c956997848489c31ed0b228a8605a9f0b5c30fad323bbeca06e3564379f273
-  data.tar.gz: b65c505cbad680da0cf1967f750408986c69cf17c0d781b21a218a3706afaf069dd10b13b3c7a0d9bbf394cb3b163e5237d7a1c2b5424d549da809f17455586d
+  metadata.gz: !binary |-
+    OGI3MTA1YmM5MjA4ZjUzYmE4Mjc0MTVmYWEzODU1NDI0ZjhiMzNlZDM3MWQ1
+    Mjk1NTIxNmY2MzA4MGYyZTEyZTRiZjExOTFiZTRkNGI3MzAyZjFkOWY3Yjdm
+    MGY5NGNmYjU5NDEwOTVjZDNjMzBiOWU5YTA5YzNmOTUwNGEzMDA=
+  data.tar.gz: !binary |-
+    OGYwZThkZjFmMDcxNzUyZTBjODBhMTgwZWYwMWVmZjU1NzAyZmVjNTg5YmY5
+    ZGQ0ODgxYmMzNjBlMTFmMDZhOTI3MmI2MTgzMGE0NDQ3ODkxYWIzYWI0NDc0
+    YzAzNzNjYzc3YzIwYzZiMGI5ZjEzN2ZjMWI5NmFlMDkzNDNlOWM=

data/.coco.yml

@@ -0,0 +1,5 @@
+:directories:
+- lib
+:excludes:
+- spec
+- .bundle

data/.gitignore

@@ -4,16 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
-InstalledFiles
 _yardoc
 coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
 spec/reports
-test/tmp
-test/version_tmp
 tmp
-html/
-etcd

data/.travis.yml

@@ -1,14 +1,10 @@
-before_install: 
-  - sudo apt-get update -y
-  - sudo add-apt-repository ppa:duh/golang -y
-  - sudo apt-get update -y
-  - sudo apt-get install golang -y
-  - git clone https://github.com/coreos/etcd
-  - cd etcd && bash build
+before_install:
+  - bash build_etcd
   - bundle install --path .bundle
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
 branches:
   only:
     - master

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in etcd.gemspec
 gemspec
+gem 'coco'
+gem 'rubocop'

data/README.md

@@ -20,9 +20,9 @@ Or install it yourself as:
 ### Create a client object
 ```ruby
 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(:host=>'127.0.0.1', :port=>4003, :allow_redirect => false) # wont let you run sensitive commands on non-leader machines, default is true
+client = Etcd.client(port: 4002)
+client = Etcd.client(host: '127.0.0.1', port: 4003)
+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
 ```ruby
@@ -38,6 +38,7 @@ client.get('/nodes/n2').value
 ### Delete a key
 ```ruby
 client.delete('/nodes/n1')
+client.delete('/nodes/', recursive: true)
 ```
 
 ### Test and set

data/build_etcd

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+wget -c https://go.googlecode.com/files/go1.2.linux-amd64.tar.gz
+tar -zxf go1.2.linux-amd64.tar.gz
+git clone https://github.com/coreos/etcd
+export GOROOT=$PWD/go
+export PATH=$GOROOT/bin:$PATH
+cd etcd && ./build

data/etcd.gemspec

@@ -18,12 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "mixlib-cli"
   spec.add_dependency "mixlib-log"
-  spec.add_dependency "uuid"
 
+  spec.add_development_dependency "uuid"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "simplecov"
 end

data/lib/etcd.rb

@@ -1,10 +1,10 @@
+# Encoding: utf-8
 
+require 'etcd/client'
 ##
 # This module provides the Etcd:: name space for the gem and few 
 # factory methods for Etcd domain objects
-require 'etcd/client'
 module Etcd
-
   ##
   # Create and return a Etcd::Client object. It takes a hash +opts+
   # as an argument which gets passed to the Etcd::Client.new method

data/lib/etcd/client.rb

@@ -0,0 +1,129 @@
+# Encoding: utf-8
+
+require 'net/http'
+require 'json'
+require 'etcd/log'
+require 'etcd/stats'
+require 'etcd/keys'
+require 'etcd/exceptions'
+require 'etcd/mod/lock'
+require 'etcd/mod/leader'
+
+module Etcd
+  ##
+  # This is the central ruby class for Etcd. It provides methods for all
+  # etcd api calls. It also provides few additional methods beyond the core
+  # 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 }
+
+    include Stats
+    include Keys
+    include Mod::Lock
+    include Mod::Leader
+
+    attr_reader :host, :port, :http, :allow_redirect
+    attr_reader :use_ssl, :verify_mode, :read_timeout
+
+    ##
+    # Creates an Etcd::Client object. It accepts a hash +opts+ as argument
+    #
+    # @param [Hash] opts The options for new Etcd::Client object
+    # @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)
+    def initialize(opts = {})
+      @host = opts[:host] || '127.0.0.1'
+      @port = opts[:port] || 4001
+      @read_timeout = opts[:read_timeout] || 60
+      @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
+    end
+
+    # Returns the etcd api version that will be used for across API methods
+    def version_prefix
+      '/v2'
+    end
+
+    # Returns the etcd daemon version
+    def version
+      api_execute('/version', :get).body
+    end
+
+    # Returns array of all machines in the cluster
+    def machines
+      api_execute(version_prefix + '/machines', :get).body.split(',').map(&:strip)
+    end
+
+    # Get the current leader
+    def leader
+      api_execute(version_prefix + '/leader', :get).body.strip
+    end
+
+    # This method sends api request to etcd server.
+    #
+    # This method has following parameters as argument
+    # * path    - etcd server path (etcd server end point)
+    # * method  - the request method used
+    # * options  - any additional parameters used by request method (optional)
+    def api_execute(path, method, options = {})
+      params = options[:params]
+      case  method
+      when :get
+        req = build_http_request(Net::HTTP::Get, path, params)
+      when :post
+        req = build_http_request(Net::HTTP::Post, path, nil, params)
+      when :put
+        req = build_http_request(Net::HTTP::Put, path, nil, params)
+      when :delete
+        req = build_http_request(Net::HTTP::Delete, path, params)
+      else
+        fail "Unknown http action: #{method}"
+      end
+      timeout = options[:timeout] || @read_timeout
+      http = Net::HTTP.new(host, port)
+      http.read_timeout = timeout
+      http.use_ssl = use_ssl
+      http.verify_mode = verify_mode
+      Log.debug("Invoking: '#{req.class}' against '#{path}")
+      res = http.request(req)
+      Log.debug("Response code: #{res.code}")
+      process_http_request(res)
+    end
+
+    def process_http_request(res)
+      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)
+        else
+          Log.debug('Http redirect not allowed')
+          res.error!
+        end
+      when HTTP_CLIENT_ERROR
+        fail Error.from_http_response(res)
+      else
+        Log.debug('Http error')
+        Log.debug(res.body)
+        res.error!
+      end
+    end
+
+    def build_http_request(klass, path, params = nil, body = nil)
+      path += '?' + URI.encode_www_form(params) unless params.nil?
+      req = klass.new(path)
+      req.body = URI.encode_www_form(body) unless body.nil?
+      Etcd::Log.debug("Built #{klass} path:'#{path}'  body:'#{req.body}'")
+      req
+    end
+  end
+end

data/lib/etcd/exceptions.rb

@@ -0,0 +1,78 @@
+# Encoding: utf-8
+
+require 'json'
+
+# Provides Etcd namespace
+module Etcd
+  # Represents all etcd custom errors
+  class Error < StandardError
+    attr_reader :cause, :error_code, :index
+
+    def initialize(opts = {})
+      super(opts['message'])
+      @cause = opts['cause']
+      @index = opts['index']
+      @error_code = opts['errorCode']
+    end
+
+    def self.from_http_response(response)
+      opts = JSON.parse(response.body)
+      unless ERROR_CODE_MAPPING.key?(opts['errorCode'])
+        fail "Unknown error code: #{opts['errorCode']}"
+      end
+      ERROR_CODE_MAPPING[opts['errorCode']].new(opts)
+    end
+
+    def inspect
+      "<#{self.class}: index:#{index}, code:#{error_code}, cause:'#{cause}'>"
+    end
+  end
+
+  # command related error
+  class KeyNotFound < Error; end
+  class TestFailed < Error; end
+  class NotFile < Error; end
+  class NoMorePeer < Error; end
+  class NotDir < Error; end
+  class NodeExist < Error; end
+  class KeyIsPreserved < Error; end
+
+  # Post form related error
+  class ValueRequired < Error; end
+  class PrevValueRequired < Error; end
+  class TTLNaN < Error; end
+  class IndexNaN < Error; end
+
+  # Raft related error
+  class RaftInternal < Error; end
+  class LeaderElect < Error; end
+
+  # Etcd related error
+  class WatcherCleared < Error; end
+  class EventIndexCleared < Error; end
+
+  ERROR_CODE_MAPPING = {
+    # command related error
+    100 => KeyNotFound,
+    101 => TestFailed,
+    102 => NotFile,
+    103 => NoMorePeer,
+    104 => NotDir,
+    105 => NodeExist,
+    106 => KeyIsPreserved,
+
+    # Post form related error
+    200 => ValueRequired,
+    201 => PrevValueRequired,
+    202 => TTLNaN,
+    203 => IndexNaN,
+
+    # Raft related error
+    300 => RaftInternal,
+    301 => LeaderElect,
+
+    # Etcd related error
+    400 => WatcherCleared,
+    401 => EventIndexCleared
+  }
+end

data/lib/etcd/keys.rb

@@ -0,0 +1,147 @@
+# Encoding: utf-8
+
+require 'json'
+require 'etcd/response'
+require 'etcd/log'
+
+module Etcd
+  # Keys module provides the basic key value operations against
+  # etcd /keys namespace
+  module Keys
+    # return etcd endpoint that is reserved for key/value store
+    def key_endpoint
+      version_prefix + '/keys'
+    end
+
+    # 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
+    def get(key, opts = {})
+      response = api_execute(key_endpoint + key, :get, params: opts)
+      Response.from_http_response(response)
+    end
+
+    # Create or update a new key
+    #
+    # This method has following parameters as argument
+    # * 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)
+      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}"
+      end
+      response = api_execute(path, :put, params: payload)
+      Response.from_http_response(response)
+    end
+
+    # Deletes a key (and its content)
+    #
+    # This method has following parameters as argument
+    # * key - key to be deleted
+    def delete(key, opts = {})
+      response = api_execute(key_endpoint + key, :delete, params: opts)
+      Response.from_http_response(response)
+    end
+
+    # Set a new value for key if previous value of key is matched
+    #
+    # This method takes following parameters as argument
+    # * 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)
+    end
+
+    # Gives a notification when specified key changes
+    #
+    # This method has following parameters as argument
+    # @ 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 = {})
+      params = { wait: true }
+      timeout = options[:timeout] || @read_timeout
+      index = options[:waitIndex] || options[:index]
+      params[:waitIndex] = index unless index.nil?
+      params[:consistent] = options[:consistent] if options.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 = {})
+      path  = key_endpoint + dir
+      payload = { 'value' => value }
+      payload['ttl'] = opts[:ttl] if opts[:ttl]
+      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
+    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)
+    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)
+    end
+
+    def eternal_watch(key, index = nil)
+      loop do
+        response = watch(key, index)
+        yield response
+      end
+    end
+
+    alias_method :key?, :exists?
+    alias_method :exist?, :exists?
+    alias_method :has_key?, :exists?
+    alias_method :test_and_set, :compare_and_swap
+  end
+end