etzetera 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b4e2c26fd128ba900ac46cd4164bf0ff33cc860
-  data.tar.gz: 941f5e9dc5e869aa0ee375c9f855ddc258afbe8e
+  metadata.gz: 47fa8b1efad7c677d6530ef9cf8c0aab5e11141a
+  data.tar.gz: c52221bb46aeae8a74de23793b20f4f8b25dcb01
 SHA512:
-  metadata.gz: 9279230c0f3162832c37bd85e08c9a8867094cb63f10624d015e5a98c01d81e3f67e1f4fe0683325eab64a2d27c79046292afee851107e74d264eb9962f18185
-  data.tar.gz: 8493e5af5b0bb162ef7c640e75ce5e727f85b41323be08b66524cb9eb1ee1d3adee46f6485eb8dd521dbff9bc8235562304ffc37355b818935c1f1a9ebbed013
+  metadata.gz: bf5cea647017f105ccc35f7d00452fbb628d0358c79cbe3dbe6b864651c56c922eba3cf7a9e47b1b5787999bfa897d7e202c77a14294dc16b17033328bd6a3ab
+  data.tar.gz: d535bc3b57d27b98685e6df01927c4a3d6ee5820bc7ff38da27133192852a207e37abbbbcc41d30c66e87816ff44caac3c5b060c86b853aaf09e87f1fb0e6993

data/lib/etzetera/client.rb

@@ -1,143 +1,140 @@
 require 'celluloid/io'
+require 'time'
 require 'multi_json'
 
 module Etzetera
   class Client
     include Celluloid::IO
-    API_ENDPOINT = 'v2'.freeze
+    API_VERSION   = 'v2'.freeze
+    KEYS_PREFIX   = "/#{API_VERSION}/keys".freeze
+    LOCK_PREFIX   = "/mod/#{API_VERSION}/lock/".freeze
+    LEADER_PREFIX = "/mod/#{API_VERSION}/leader/".freeze
+    STATS_PREFIX  = "/#{API_VERSION}/stats/".freeze
+
+    execute_block_on_receiver :wait
 
     attr_accessor :servers
 
     def initialize(servers = ['http://127.0.0.1:4001'], default_options = {})
 
-      self.servers = servers
+      self.servers = servers.dup
+
+      def_opts = default_options.dup
 
       opts = {}
-      opts[:follow]             = true
       opts[:headers]            = {:accept => 'application/json'}
       opts[:response]           = :object
-      opts[:election_timeout]   = 200
-      opts[:heartbeat_interval] = 50
       opts[:socket_class]       = Celluloid::IO::TCPSocket
       opts[:ssl_socket_class]   = Celluloid::IO::SSLSocket
 
-      @default_options = ::HTTP::Options.new(opts.merge(default_options))
+      @etcd_opts = {}
+      @etcd_opts[:election_timeout]   = def_opts.delete(:election_timeout) {|key| 200}
+      @etcd_opts[:heartbeat_interval] = def_opts.delete(:heartbeat_interval) {|key| 50}
+
+
+      @default_options = ::HTTP::Options.new(opts.merge(def_opts))
     end
 
     def get(key, params = {})
-      request(:get, keys_path(key), :params => params)
+      request(:get, KEYS_PREFIX, key, :params => params)
     end
 
     def set(key, form, params = {})
-      request(:put, keys_path(key), form: form, :params => params)
+      request(:put, KEYS_PREFIX, key, form: form, :params => params)
     end
 
     def delete(key, params = {})
-      request(:delete, keys_path(key), :params => params)
+      request(:delete, KEYS_PREFIX, key, :params => params)
     end
 
-    def wait(key, params = {}, &callback)
-      response = request(:get, keys_path(key), :params => params.merge({:wait => true}))
+    def wait(key, callback = nil, params = {})
+      response = request(:get, KEYS_PREFIX, key, :params => params.merge({:wait => true}))
 
       if block_given?
         yield response
       elsif callback
-        after(@default_options[:heartbeat_interval] / 1000.0) do
-          callback.call(response)
-        end
+        #sleep (@etcd_opts[:heartbeat_interval] / 1000.0)
+        callback.call(response)
       else
         parse_response(response)
       end
     end
 
     def create(key, form, params = {})
-      request(:put, keys_path(key), form: form, :params => params.merge({:prevExist => false}))
+      request(:put, KEYS_PREFIX, key, form: form, :params => params.merge({:prevExist => false}))
     end
 
     def update(key, form, params = {})
-      request(:put, keys_path(key), form: form, :params => params.merge({:prevExist => true}))
+      request(:put, KEYS_PREFIX, key, form: form, :params => params.merge({:prevExist => true}))
+    end
+
+    def mkdir(dir)
+      request(:put, KEYS_PREFIX, dir, :params => {dir: true})
     end
 
     def dir(dir, params = {})
-      request(:get, keys_path(dir), :params => params.merge({:recursive => true}))
+      request(:get, KEYS_PREFIX, dir, :params => params.merge({:recursive => true}))
     end
 
     def rmdir(dir, params = {})
-      request(:delete, keys_path(dir), :params => {:recursive => true}.merge(params))
+      request(:delete, KEYS_PREFIX, dir, :params => {:recursive => true}.merge(params))
     end
 
-    def compareAndSwap(key, prevValue)
-      request(:put, keys_path(key), :params => {:prevValue => prevValue})
+    def compareAndSwap(key, prevValue, form)
+      request(:put, KEYS_PREFIX, key, :form => form, :params => {:prevValue => prevValue})
     end
 
     def compareAndDelete(key, prevValue)
-      request(:delete, keys_path(key), :params => {:prevValue => prevValue})
+      request(:delete, KEYS_PREFIX, key, :params => {:prevValue => prevValue})
     end
 
     def acquire_lock(name, ttl)
-      request(:post, lock_path(name), :form => {:ttl => ttl})
+      request(:post, LOCK_PREFIX, name, :form => {:ttl => ttl})
     end
 
     def renew_lock(name, form)
-      request(:put, lock_path(name), :form => form)
+      request(:put, LOCK_PREFIX, name, :form => form)
     end
 
     def release_lock(name, form)
-      request(:delete, lock_path(name), :form => form)
+      request(:delete, LOCK_PREFIX, name, :form => form)
     end
 
     def retrieve_lock(name, params)
-      request(:get, lock_path(name), :params => params)
+      request(:get, LOCK_PREFIX, name, :params => params)
     end
 
     def set_leader(clustername, name, ttl)
-      request(:put, leader_path(clustername), :form => {:name => name, :ttl => ttl})
+      request(:put, LEADER_PREFIX, clustername, :form => {:name => name, :ttl => ttl})
     end
 
     def get_leader(clustername, params = {})
-      request(:get, leader_path(clustername), :params => params)
+      request(:get, LEADER_PREFIX, clustername, :params => params)
     end
 
     def delete_leader(clustername, name)
-      request(:delete, leader_path(clustername), :form => {:name => name})
+      request(:delete, LEADER_PREFIX, clustername, :form => {:name => name})
     end
 
     def stats(type)
-      request(:get, stats_path(type))
+      request(:get, STATS_PREFIX, type)
     end
 
     private
-    def keys_path(key)
-      "/#{API_ENDPOINT}/keys/#{key}"
-    end
-
-    def lock_path(name)
-      "/mod/#{API_ENDPOINT}/lock/#{name}"
-    end
-
-    def leader_path(clustername)
-      "/mod/#{API_ENDPOINT}/leader/#{clustername}"
-    end
-
-    def stats_path(type)
-      "/#{API_ENDPOINT}/stats/#{type}"
-    end
-
-    def request(verb, path, options = {})
+    def request(verb, prefix, path, options = {})
       opts = @default_options.merge(options)
 
+      if opts[:form] && !opts[:form].is_a?(Hash)
+        opts = opts.with_form({:value => opts[:form]})
+      end
+
       client  = ::HTTP::Client.new(opts)
       server  = servers.first
       retries = servers.count - 1
       request = nil
-
       begin
-        request = client.request(verb, "#{server}#{path}")
-        response = MultiJson.load(request.body)
-        if response['errorCode']
-          abort Error::CODES[response['errorCode']].new(response['message'])
-        end
-        parse_response(response)
+        request = client.request(verb, "#{server}#{prefix}#{path}")
+        MultiJson.load(request.body)
       rescue IOError => e
         abort e if retries < 1
 
@@ -152,11 +149,16 @@ module Etzetera
 
         retries -= 1
 
-        after(@default_options[:election_timeout] / 1000.0) do
-          retry
-        end
+        #sleep (@etcd_opts[:election_timeout] / 1000.0)
+        retry
       rescue MultiJson::LoadError => e
-        if request.code.between?(400, 499)
+        if request.code.between?(200, 299)
+          request.body.to_s
+        elsif request.code.between?(300, 399)
+          if request.headers['Location']
+            request(verb, request.headers['Location'], opts)
+          end
+        elsif request.code.between?(400, 499)
           abort Error::HttpClientError.new("#{request.reason}\n#{request.body.to_s}")
         elsif request.code.between?(500, 599)
           abort Error::HttpServerError.new("#{request.reason}\n#{request.body.to_s}")
@@ -165,9 +167,5 @@ module Etzetera
         end
       end
     end
-
-    def parse_response(response)
-      response
-    end
   end
 end

data/lib/etzetera/error.rb

@@ -21,6 +21,7 @@ module Etzetera
     class NotDir < CommandError; end
     class NodeExist < CommandError; end
     class KeyIsPreserved < CommandError; end
+    class RootROnly < CommandError; end
 
     class ValueRequired < PostFormError; end
     class PrevValueRequired < PostFormError; end
@@ -41,6 +42,7 @@ module Etzetera
       104 => NotDir,
       105 => NodeExist,
       106 => KeyIsPreserved,
+      107 => RootROnly,
       200 => ValueRequired,
       201 => PrevValueRequired,
       202 => TTLNaN,

data/lib/etzetera/version.rb

@@ -1,3 +1,3 @@
 module Etzetera
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: etzetera
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Hendrik
@@ -31,62 +31,62 @@ cert_chain:
   fESaRa24pr3CGd0AyltcRbKGfNpZfj1zfqWXrDUJj0Y1sOASd8+UZPmBFS2feJqy
   het/fGFD7akMwHXIlNxNsg==
   -----END CERTIFICATE-----
-date: 2014-03-04 00:00:00.000000000 Z
+date: 2014-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.15'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.15'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 1.8.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 1.8.4
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
 description: A etcd Client written in Ruby