etcdv3 0.10.1 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: eea828b2c14cfeab2c0f9be8a84ea937131a5dc2
-  data.tar.gz: a2e02f9d0155f35185994c07cd7abc5a6d23d5df
+SHA256:
+  metadata.gz: 59585a18eada27829edbf162733146e90e4c336bcbbefa761b3063e3f9400139
+  data.tar.gz: edc026da35b1396e664a431a79eb2012238ea4bd49c8ef43e1f70f93366935fe
 SHA512:
-  metadata.gz: bff96b426657924163a26df9ca1322b5600b33607453d4648affffe2e66bf7c7ef20e5fe2d0443435de71b74d9ceec637f968196315837426294d26dd1b84e78
-  data.tar.gz: 1a10f332e633b1010aba3a355b05ef82e2546e37413222de7553bcdb2461d0d2b368573af75a33e927349c4f461c81564d80adbe149ea7f6e5ac8b478158cc1e
+  metadata.gz: d5afcdcad7f96e422bebcd6d4d4db148bbe48c8600be017650ae229d988cd2e5c6d3547f2026eb1db18a10c91643ba3e84bb0a2555b2f8add7f687dd9bfc014a
+  data.tar.gz: 310680f7f8f11b65dfb9ea1a116536394678faf05f29087a77b87b1665138f85c4bc39614299dff22a528a63f0a0771dbb3841e9b60a610611dacff33048fbf1

data/.gitignore

@@ -1,9 +1,10 @@
-Gemfile.lock
-Guardfile
-*.sh
 *.gem
-/tmp/
+*.sh
+*.swp
+/.bundle
 /.idea
 /coverage/*
 /doc/
-*.swp
+/tmp/
+Gemfile.lock
+Guardfile

data/README.md

@@ -26,6 +26,9 @@ conn = Etcdv3.new(endpoints: 'https://hostname:port')
 # Secure connection with Auth
 conn = Etcdv3.new(endpoints: 'https://hostname:port', user: 'root', password: 'mysecretpassword')
 
+# Scope CRUD operations to a specific keyspace. 
+conn = Etcdv3.new(endpoints: 'https://hostname:port', namespace: "/target_keyspace/")
+
 # Secure connection specifying custom certificates
 # Coming soon...
 
@@ -34,6 +37,37 @@ conn = Etcdv3.new(endpoints: 'https://hostname:port', user: 'root', password: 'm
 
 In the event of a failure, the client will work to restore connectivity by cycling through the specified endpoints until a connection can be established.  With that being said, it is encouraged to specify multiple endpoints when available.
 
+However, sometimes this is not what you want. If you need more control over
+failures, you can suppress this mechanism by using
+
+```ruby
+conn = Etcdv3.new(endpoints: 'https://hostname:port', allow_reconnect: false)
+```
+
+This will still rotate the endpoints, but it will raise an exception so you can
+handle the failure yourself. On next call to the new endpoint (since they were
+rotated) is tried. One thing you need to keep in mind if auth is enabled, you 
+need to take care of `GRPC::Unauthenticated` exception and manually re-authenticate 
+when token expires. To reiterate, you are responsible for handling the errors, so 
+some understanding of how this gem and etcd works is recommended.
+
+## Namespace support
+
+Namespacing is a convenience feature used to scope CRUD based operations to a specific keyspace.
+
+```ruby
+# Establish connection
+conn = Etcdv3.new(endpoints: 'https://hostname:port', namespace: '/service-a/')
+
+# Write key to /service-a/test_key
+conn.put("test_key", "value"). 
+
+# Get the key we just wrote.
+conn.get("test_key")
+```
+
+_Note: Namespaces are stripped from responses._
+
 
 ## Adding, Fetching and Deleting Keys
 ```ruby

data/lib/etcdv3.rb

@@ -7,6 +7,14 @@ require 'etcdv3/auth'
 require 'etcdv3/kv/requests'
 require 'etcdv3/kv/transaction'
 require 'etcdv3/kv'
+
+require 'etcdv3/namespace/utilities'
+require 'etcdv3/namespace/kv/requests'
+require 'etcdv3/namespace/kv/transaction'
+require 'etcdv3/namespace/lock'
+require 'etcdv3/namespace/kv'
+require 'etcdv3/namespace/watch'
+
 require 'etcdv3/maintenance'
 require 'etcdv3/lease'
 require 'etcdv3/watch'
@@ -21,10 +29,16 @@ class Etcdv3
   attr_reader :conn, :credentials, :options
   DEFAULT_TIMEOUT = 120
 
-  def initialize(options = {})
+  def initialize(**options)
     @options = options
     @timeout = options[:command_timeout] || DEFAULT_TIMEOUT
-    @conn = ConnectionWrapper.new(@timeout, *sanitized_endpoints)
+    @namespace = options[:namespace]
+    @conn = ConnectionWrapper.new(
+      @timeout,
+      *sanitized_endpoints,
+      @namespace,
+      @options.fetch(:allow_reconnect, true),
+    )
     warn "WARNING: `url` is deprecated. Please use `endpoints` instead." if @options.key?(:url)
     authenticate(@options[:user], @options[:password]) if @options.key?(:user)
   end

data/lib/etcdv3/connection.rb

@@ -1,6 +1,12 @@
 class Etcdv3
   class Connection
 
+    NAMESPACE_HANDLERS = {
+      kv: Etcdv3::Namespace::KV,
+      watch: Etcdv3::Namespace::Watch,
+      lock: Etcdv3::Namespace::Lock,
+    }
+
     HANDLERS = {
       auth: Etcdv3::Auth,
       kv: Etcdv3::KV,
@@ -10,11 +16,12 @@ class Etcdv3
       lock: Etcdv3::Lock,
     }
 
-    attr_reader :endpoint, :hostname, :handlers, :credentials
+    attr_reader :endpoint, :hostname, :handlers, :credentials, :namespace
 
-    def initialize(url, timeout, metadata={})
+    def initialize(url, timeout, namespace, metadata={})
       @endpoint = URI(url)
       @hostname = "#{@endpoint.hostname}:#{@endpoint.port}"
+      @namespace = namespace
       @credentials = resolve_credentials
       @timeout = timeout
       @handlers = handler_map(metadata)
@@ -31,11 +38,19 @@ class Etcdv3
     private
 
     def handler_map(metadata={})
-      Hash[
+      handlers = Hash[
         HANDLERS.map do |key, klass|
-          [key, klass.new("#{@hostname}", @credentials, @timeout, metadata)]
+          [key, klass.new(@hostname, @credentials, @timeout, metadata)]
         end
       ]
+      # Override any handlers that are namespace compatable.
+      if @namespace
+        NAMESPACE_HANDLERS.each do |key, klass|
+          handlers[key] = klass.new(@hostname, @credentials, @timeout, @namespace, metadata)
+        end
+      end
+      
+      handlers
     end
 
     def resolve_credentials

data/lib/etcdv3/connection_wrapper.rb

@@ -3,31 +3,40 @@ class Etcdv3
 
     attr_accessor :connection, :endpoints, :user, :password, :token, :timeout
 
-    def initialize(timeout, *endpoints)
+    def initialize(timeout, *endpoints, namespace, allow_reconnect)
       @user, @password, @token = nil, nil, nil
       @timeout = timeout
-      @endpoints = endpoints.map{|endpoint| Etcdv3::Connection.new(endpoint, @timeout) }
+      @namespace = namespace
+      @endpoints = endpoints.map{|endpoint| Etcdv3::Connection.new(endpoint, @timeout, @namespace) }
+      @allow_reconnect = allow_reconnect
       @connection = @endpoints.first
     end
 
+    private def retry_or_raise(*args)
+      if @allow_reconnect
+        handle(*args)
+      else
+        raise
+      end
+    end
+
     def handle(stub, method, method_args=[], retries: 1)
       @connection.call(stub, method, method_args)
 
-    rescue GRPC::Unavailable, GRPC::Core::CallError => exception
+    rescue GRPC::Unavailable, GRPC::Core::CallError
       $stderr.puts("Failed to connect to endpoint '#{@connection.hostname}'")
       if @endpoints.size > 1
         rotate_connection_endpoint
-        $stderr.puts("Failover event triggered. Failing over to '#{@connection.hostname}'")
-        return handle(stub, method, method_args)
+        return retry_or_raise(stub, method, method_args)
       else
-        return handle(stub, method, method_args)
+        return retry_or_raise(stub, method, method_args)
       end
     rescue GRPC::Unauthenticated => exception
       # Regenerate token in the event it expires.
       if exception.details == 'etcdserver: invalid auth token'
         if retries > 0
           authenticate(@user, @password)
-          return handle(stub, method, method_args, retries: retries - 1)
+          return retry_or_raise(stub, method, method_args, retries: retries - 1)
         end
       end
       raise exception

data/lib/etcdv3/namespace/kv.rb

@@ -0,0 +1,62 @@
+class Etcdv3::Namespace
+  class KV
+    include Etcdv3::Namespace::KV::Requests
+    include Etcdv3::Namespace::Utilities
+    include GRPC::Core::TimeConsts
+  
+    def initialize(hostname, credentials, timeout, namespace, metadata={})
+      @stub = Etcdserverpb::KV::Stub.new(hostname, credentials)
+      @timeout = timeout
+      @namespace = namespace
+      @metadata = metadata
+    end
+
+    def get(key, opts={})
+      timeout = opts.delete(:timeout)
+      resp = @stub.range(get_request(key, opts), metadata: @metadata, deadline: deadline(timeout))
+      strip_prefix(@namespace, resp)
+    end
+
+    def del(key, range_end: '', timeout: nil)
+      resp = @stub.delete_range(del_request(key, range_end), metadata: @metadata, deadline: deadline(timeout))
+      strip_prefix(@namespace, resp)
+    end
+
+    def put(key, value, lease: nil, timeout: nil)
+      resp = @stub.put(put_request(key, value, lease), metadata: @metadata, deadline: deadline(timeout))
+      strip_prefix(@namespace, resp)
+    end
+
+    def transaction(block, timeout: nil)
+      txn = Etcdv3::Namespace::KV::Transaction.new(@namespace)
+      block.call(txn)
+      request = Etcdserverpb::TxnRequest.new(
+        compare: txn.compare,
+        success: generate_request_ops(txn.success),
+        failure: generate_request_ops(txn.failure),
+      )
+      resp = @stub.txn(request, metadata: @metadata, deadline: deadline(timeout))
+      strip_prefix(@namespace, resp)
+    end
+
+    private
+
+    def deadline(timeout)
+      from_relative_time(timeout || @timeout)
+    end
+
+    def generate_request_ops(requests)
+      requests.map do |request|
+        if request.is_a?(Etcdserverpb::RangeRequest)
+          Etcdserverpb::RequestOp.new(request_range: request)
+        elsif request.is_a?(Etcdserverpb::PutRequest)
+          Etcdserverpb::RequestOp.new(request_put: request)
+        elsif request.is_a?(Etcdserverpb::DeleteRangeRequest)
+          Etcdserverpb::RequestOp.new(request_delete_range: request)
+        else
+          raise "Invalid command. Not sure how you got here!"
+        end
+      end
+    end
+  end
+end

data/lib/etcdv3/namespace/kv/requests.rb

@@ -0,0 +1,54 @@
+class Etcdv3::Namespace::KV
+  module Requests
+
+    SORT_TARGET = {
+      key: 0,
+      version: 1,
+      create: 2,
+      mod: 3,
+      value: 4
+    }
+
+    SORT_ORDER = {
+      none: 0,
+      ascend: 1,
+      descend: 2
+    }
+
+    def get_request(key, opts)
+      key = prepend_prefix(@namespace, key)
+      # In order to enforce the scope of the specified namespace, we are going to
+      # intercept the zero-byte reference and re-target everything under the given namespace.
+      if opts[:range_end] =~ /\x00/
+        opts[:range_end] = (@namespace[0..-2] + (@namespace[-1].ord + 1).chr)
+      else 
+        opts[:range_end] = prepend_prefix(@namespace, opts[:range_end]) if opts[:range_end]
+      end
+      opts[:sort_order] = SORT_ORDER[opts[:sort_order]] \
+        if opts[:sort_order]
+      opts[:sort_target] = SORT_TARGET[opts[:sort_target]] \
+        if opts[:sort_target]
+      opts[:key] = key
+      Etcdserverpb::RangeRequest.new(opts)
+    end
+
+    def del_request(key, range_end=nil)
+      key = prepend_prefix(@namespace, key)
+      # In order to enforce the scope of the specified namespace, we are going to
+      # intercept the zero-byte reference and re-target everything under the given namespace.
+      if range_end =~ /\x00/
+        range_end = (@namespace[0..-2] + (@namespace[-1].ord + 1).chr)
+      else 
+        range_end = prepend_prefix(@namespace, range_end) if range_end
+      end
+      Etcdserverpb::DeleteRangeRequest.new(key: key, range_end: range_end)
+    end
+
+    def put_request(key, value, lease=nil)
+      key = prepend_prefix(@namespace, key)
+      kv = Etcdserverpb::PutRequest.new(key: key, value: value)
+      kv.lease = lease if lease
+      kv
+    end
+  end
+end

data/lib/etcdv3/namespace/kv/transaction.rb

@@ -0,0 +1,91 @@
+class Etcdv3::Namespace::KV
+  class Transaction
+    include Etcdv3::Namespace::Utilities
+    include Etcdv3::Namespace::KV::Requests
+
+    # Available comparison identifiers.
+    COMPARISON_IDENTIFIERS = {
+      equal: 0,
+      greater: 1,
+      less: 2,
+      not_equal: 3
+    }
+
+    # Available targets to compare with.
+    TARGETS = {
+      version: 0,
+      create_revision: 1,
+      mod_revision: 2,
+      value: 3
+    }
+
+    attr_writer :compare, :success, :failure
+
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    def compare
+      @compare ||= []
+    end
+
+    def success
+      @success ||= []
+    end
+
+    def failure
+      @failure ||=[]
+    end
+
+    # Request Operations
+
+    # txn.put('my', 'key', lease_id: 1)
+    def put(key, value, lease=nil)
+      put_request(key, value, lease)
+    end
+
+    # txn.get('key')
+    def get(key, opts={})
+      get_request(key, opts)
+    end
+
+    # txn.del('key')
+    def del(key, range_end='')
+      del_request(key, range_end)
+    end
+
+    ###  Compare Operations
+
+    # txn.version('names', :greater, 0 )
+    def version(key, compare_type, value)
+      generate_compare(:version, key, compare_type, value)
+    end
+
+    # txn.value('names', :equal, 'wowza' )
+    def value(key, compare_type, value)
+      generate_compare(:value, key, compare_type, value)
+    end
+
+    # txn.mod_revision('names', :not_equal, 0)
+    def mod_revision(key, compare_type, value)
+      generate_compare(:mod_revision, key, compare_type, value)
+    end
+
+    # txn.create_revision('names', :less, 10)
+    def create_revision(key, compare_type, value)
+      generate_compare(:create_revision, key, compare_type, value)
+    end
+
+    private
+
+    def generate_compare(target_union, key, compare_type, value)
+      key = prepend_prefix(@namespace, key)    
+      Etcdserverpb::Compare.new(
+        key: key,
+        result: COMPARISON_IDENTIFIERS[compare_type],
+        target: TARGETS[target_union],
+        target_union => value
+      )
+    end
+  end
+end

data/lib/etcdv3/namespace/lock.rb

@@ -0,0 +1,32 @@
+class Etcdv3::Namespace
+  class Lock
+    include GRPC::Core::TimeConsts
+    include Etcdv3::Namespace::Utilities
+
+    def initialize(hostname, credentials, timeout, namespace, metadata = {})
+      @stub = V3lockpb::Lock::Stub.new(hostname, credentials)
+      @timeout = timeout
+      @namespace = namespace
+      @metadata = metadata
+    end
+
+    def lock(name, lease_id, timeout: nil)
+      name = prepend_prefix(@namespace, name)
+      request = V3lockpb::LockRequest.new(name: name, lease: lease_id)
+      resp = @stub.lock(request, deadline: deadline(timeout))
+      strip_prefix_from_lock(@namespace, resp)
+    end
+
+    def unlock(key, timeout: nil)
+      key = prepend_prefix(@namespace, key)
+      request = V3lockpb::UnlockRequest.new(key: key)
+      @stub.unlock(request, deadline: deadline(timeout))
+    end
+
+    private
+
+    def deadline(timeout)
+      from_relative_time(timeout || @timeout)
+    end
+  end
+end

data/lib/etcdv3/namespace/utilities.rb

@@ -0,0 +1,44 @@
+class Etcdv3::Namespace
+  module Utilities
+    
+    def prepend_prefix(prefix, key)
+      key = key.dup if key.frozen?
+      key.prepend(prefix)
+    end
+
+    def strip_prefix(prefix, resp)
+      [:kvs, :prev_kvs].each do |field|
+        if resp.respond_to?(field)
+          resp.send(field).each do |kv| 
+            kv.key = delete_prefix(prefix, kv.key)
+          end
+        end
+      end
+      resp
+    end
+
+    def strip_prefix_from_lock(prefix, resp)
+      if resp.key
+        resp.key = delete_prefix(prefix, resp.key)
+      end
+      resp 
+    end
+
+    def strip_prefix_from_events(prefix, events)
+      events.each do |event|
+        if event.kv
+          event.kv.key = delete_prefix(prefix, event.kv.key)
+        end
+        if event.prev_kv
+          event.prev_kv.key = delete_prefix(prefix, event.prev_kv.key)
+        end
+        event 
+      end
+    end
+
+    def delete_prefix(prefix, str)
+      str.sub(/\A#{prefix}/, '')
+    end
+
+  end
+end

data/lib/etcdv3/namespace/watch.rb

@@ -0,0 +1,38 @@
+class Etcdv3::Namespace
+  class Watch
+    include GRPC::Core::TimeConsts
+    include Etcdv3::Namespace::Utilities
+
+    def initialize(hostname, credentials, timeout, namespace, metadata = {})
+      @stub = Etcdserverpb::Watch::Stub.new(hostname, credentials)
+      @timeout = timeout
+      @namespace = namespace
+      @metadata = metadata
+    end
+
+    def watch(key, range_end, start_revision, block, timeout: nil)      
+      key = prepend_prefix(@namespace, key)
+      range_end = prepend_prefix(@namespace, range_end) if range_end
+      create_req = Etcdserverpb::WatchCreateRequest.new(key: key)
+      create_req.range_end = range_end if range_end
+      create_req.start_revision = start_revision if start_revision
+      watch_req = Etcdserverpb::WatchRequest.new(create_request: create_req)
+      events = nil
+      @stub.watch([watch_req], metadata: @metadata, deadline: deadline(timeout)).each do |resp|
+        next if resp.events.empty?
+        if block
+          block.call(strip_prefix_from_events(@namespace, resp.events))
+        else
+          events = strip_prefix_from_events(@namespace, resp.events)
+          break
+        end
+      end
+      events
+    end
+
+    def deadline(timeout)
+      from_relative_time(timeout || @timeout)
+    end
+
+  end
+end

data/lib/etcdv3/version.rb

@@ -1,3 +1,3 @@
 class Etcdv3
-  VERSION = '0.10.1'.freeze
+  VERSION = '0.11.3'.freeze
 end

data/spec/etcdv3/connection_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Etcdv3::Connection do
 
   describe '#initialize - without metadata' do
-    subject { Etcdv3::Connection.new('http://localhost:2379', 10) }
+    subject { Etcdv3::Connection.new('http://localhost:2379', 10, nil) }
 
     it { is_expected.to have_attributes(endpoint: URI('http://localhost:2379')) }
     it { is_expected.to have_attributes(credentials: :this_channel_is_insecure) }
@@ -22,7 +22,7 @@ describe Etcdv3::Connection do
   end
 
   describe '#initialize - with metadata' do
-    subject { Etcdv3::Connection.new('http://localhost:2379', 10, token: 'token123') }
+    subject { Etcdv3::Connection.new('http://localhost:2379', 10, nil, token: 'token123') }
 
     [:kv, :maintenance, :lease, :watch, :auth].each do |handler|
       let(:handler_stub) { subject.handlers[handler].instance_variable_get(:@stub) }
@@ -37,7 +37,7 @@ describe Etcdv3::Connection do
   end
 
   describe '#refresh_metadata' do
-    subject { Etcdv3::Connection.new('http://localhost:2379', token: 'token123') }
+    subject { Etcdv3::Connection.new('http://localhost:2379', nil, token: 'token123') }
     before { subject.refresh_metadata(token: 'newtoken') }
     [:kv, :maintenance, :lease, :watch, :auth].each do |handler|
       let(:handler_metadata) { subject.handlers[handler].instance_variable_get(:@metadata) }

data/spec/etcdv3/connection_wrapper_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Etcdv3::ConnectionWrapper do
   let(:conn) { local_connection }
   let(:endpoints) { ['http://localhost:2379', 'http://localhost:2389'] }
+  subject { Etcdv3::ConnectionWrapper.new(10, *endpoints, nil, true) }
 
   describe '#initialize' do
-    subject { Etcdv3::ConnectionWrapper.new(10, *endpoints) }
     it { is_expected.to have_attributes(user: nil, password: nil, token: nil) }
     it 'sets hostnames in correct order' do
       expect(subject.endpoints.map(&:hostname)).to eq(['localhost:2379', 'localhost:2389'])
@@ -16,7 +16,6 @@ describe Etcdv3::ConnectionWrapper do
   end
 
   describe "#rotate_connection_endpoint" do
-    subject { Etcdv3::ConnectionWrapper.new(10, *endpoints) }
     before do
       subject.rotate_connection_endpoint
     end
@@ -29,11 +28,30 @@ describe Etcdv3::ConnectionWrapper do
   end
 
   describe "Failover Simulation" do
-    let(:modified_conn) { local_connection("http://localhost:2369, http://localhost:2379") }
+    let(:allow_reconnect) { true }
+    let(:modified_conn) {
+      local_connection(
+        "http://localhost:2369, http://localhost:2379",
+        allow_reconnect: allow_reconnect
+      )
+    }
+    subject { modified_conn.get('boom') }
+
     context 'without auth' do
       # Set primary endpoint to a non-existing etcd endpoint
-      subject { modified_conn.get('boom') }
-      it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      context 'with reconnect' do
+        it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      end
+      context 'without reconnect' do
+        let(:allow_reconnect) { false }
+        it { expect { subject }.to raise_error(GRPC::Unavailable) }
+      end
+      context 'without reconnect with single endpoint' do
+        let(:modified_conn) {
+          local_connection("http://localhost:2369",allow_reconnect: false)
+        }
+        it { expect { subject }.to raise_error(GRPC::Unavailable) }
+      end
     end
     context 'with auth' do
       before do
@@ -50,12 +68,19 @@ describe Etcdv3::ConnectionWrapper do
         modified_conn.auth_disable
         modified_conn.user_delete('root')
       end
-      subject { modified_conn.get('boom') }
-      it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      context 'with reconnect' do
+        it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      end
+      context 'without reconnect' do
+        let(:allow_reconnect) { false }
+        it { expect { subject }.to raise_error(GRPC::Unavailable) }
+      end
     end
   end
 
   describe "GRPC::Unauthenticated recovery" do
+    let(:allow_reconnect) { true }
+    let(:conn) { local_connection(allow_reconnect: allow_reconnect) }
     let(:wrapper) { conn.send(:conn) }
     let(:connection) { wrapper.connection }
     before do
@@ -71,6 +96,12 @@ describe Etcdv3::ConnectionWrapper do
       conn.user_delete('root')
     end
     subject { conn.user_get('root') }
-    it { is_expected.to be_an_instance_of(Etcdserverpb::AuthUserGetResponse) }
+    context 'with reconnect' do
+      it { is_expected.to be_an_instance_of(Etcdserverpb::AuthUserGetResponse) }
+    end
+    context 'without reconnect' do
+      let(:allow_reconnect) { false }
+      it { expect { subject }.to raise_error(GRPC::Unauthenticated) }
+    end
   end
 end

data/spec/etcdv3/namespace/kv_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Etcdv3::KV do
+  let(:stub) { local_namespace_stub(Etcdv3::Namespace::KV, 1, '/namespace/') }
+  let(:lease_stub) { local_stub(Etcdv3::Lease, 1) }
+
+  it_should_behave_like "a method with a GRPC timeout", described_class, :get, :range, "key"
+  it_should_behave_like "a method with a GRPC timeout", described_class, :del, :delete_range, "key"
+  it_should_behave_like "a method with a GRPC timeout", described_class, :put, :put, "key", "val"
+
+  it "should timeout transactions" do
+    stub = local_namespace_stub(Etcdv3::Namespace::KV, 0, '/namespace/')
+    expect { stub.transaction(Proc.new { nil }) }.to raise_error(GRPC::DeadlineExceeded)
+  end
+
+  describe '#put' do
+    context 'without lease' do
+      subject { stub.put('test', 'test') }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::PutResponse) }
+    end
+
+    context 'with lease' do
+      let(:lease_id) { lease_stub.lease_grant(1)['ID'] }
+      subject { stub.put('lease', 'test', lease: lease_id) }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::PutResponse) }
+    end
+  end
+
+  describe '#get' do
+    subject { stub.get('test') }
+    it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+  end
+
+  describe '#del' do
+    context 'del without range' do
+      subject { stub.del('test') }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::DeleteRangeResponse) }
+    end
+    context 'del with range' do
+      subject { stub.del('test', range_end: 'testtt') }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::DeleteRangeResponse) }
+    end
+  end
+
+  describe '#transaction' do
+    context 'put' do
+      let!(:block) do
+        Proc.new do |txn|
+          txn.compare = [ txn.value('txn', :equal, 'value') ]
+          txn.success = [ txn.put('txn-test', 'success') ]
+          txn.failure = [ txn.put('txn-test', 'failed') ]
+        end
+      end
+      subject { stub.transaction(block) }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::TxnResponse) }
+    end
+
+    context 'del' do
+      let!(:block) do
+        Proc.new do |txn|
+          txn.compare = [ txn.value('txn', :equal, 'value') ]
+          txn.success = [ txn.del('txn-one') ]
+          txn.failure = [ txn.del('txn-two') ]
+        end
+      end
+      subject { stub.transaction(block) }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::TxnResponse) }
+    end
+  end
+
+  context 'get' do
+    let!(:block) do
+      Proc.new do |txn|
+        txn.compare = [ txn.value('txn', :equal, 'value') ]
+        txn.success = [ txn.get('txn-success') ]
+        txn.failure = [ txn.get('txn-failure') ]
+      end
+    end
+    subject { stub.transaction(block) }
+    it { is_expected.to be_an_instance_of(Etcdserverpb::TxnResponse) }
+  end
+end

data/spec/etcdv3/namespace/lock_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+# Locking is not implemented in etcd v3.1.X
+unless $instance.version < Gem::Version.new("3.2.0")
+  describe Etcdv3::Lock do
+    let(:stub) { local_namespace_stub(Etcdv3::Namespace::Lock, 1, '/namespace/') }
+    let(:lease_stub) { local_stub(Etcdv3::Lease, 1) }
+
+    it_should_behave_like "a method with a GRPC timeout", described_class, :unlock, :unlock, 'foo'
+    # it_should_behave_like "a method with a GRPC timeout", described_class, :lock, :lock, 'foo'
+
+    describe '#lock' do
+      let(:lease_id) { lease_stub.lease_grant(10)['ID'] }
+      subject { stub.lock('foo', lease_id) }
+      it { is_expected.to be_an_instance_of(V3lockpb::LockResponse) }
+    end
+
+    describe '#unlock' do
+      subject { stub.unlock('foo') }
+      it { is_expected.to be_an_instance_of(V3lockpb::UnlockResponse) }
+    end
+  end
+end

data/spec/etcdv3/namespace/watch_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'securerandom'
+
+
+describe Etcdv3::Namespace::Watch do
+  let(:stub) { local_namespace_stub(Etcdv3::Namespace::Watch, 5, '/namespace/') }
+  let(:kv_stub_no_ns) { local_stub(Etcdv3::KV, 1) }
+  let(:kv_stub) { local_namespace_stub(Etcdv3::Namespace::KV, 1, '/namespace/') }
+
+  context 'watch' do
+    it 'should return an event' do 
+      resp = nil
+      thr = Thread.new do |thr|
+        resp = stub.watch("foo", nil, 1, nil)
+      end
+      sleep 2
+      kv_stub.put("foo", "works")
+      thr.join
+      expect(resp).to be_an_instance_of(Google::Protobuf::RepeatedField)
+      expect(resp.last.kv.key).to eq('foo')  
+    end
+
+    it 'should return event when non-namespace client writes to key' do 
+      resp = nil
+      thr = Thread.new do |thr|
+        resp = stub.watch("foobar", nil, 1, nil)
+      end
+      sleep 2
+      kv_stub_no_ns.put("/namespace/foobar", "works")
+      thr.join
+      expect(resp).to be_an_instance_of(Google::Protobuf::RepeatedField)
+      expect(resp.last.kv.key).to eq('foobar')  
+    end
+  end
+end
+

data/spec/etcdv3/watch_spec.rb

@@ -4,14 +4,21 @@ require 'securerandom'
 # Locking is not implemented in etcd v3.1.X
 unless $instance.version < Gem::Version.new("3.2.0")
   describe Etcdv3::Watch do
-    let(:stub) { local_stub(Etcdv3::Watch, 1) }
+    let(:stub) { local_stub(Etcdv3::Watch, 5) }
     let(:kv_stub) { local_stub(Etcdv3::KV, 1) }
 
-    context 'xxx' do
-      before(:each) do
-        kv_stub.put 'foo', 'bar'
+    context 'watch' do
+      it 'should return an event' do 
+        resp = nil
+        thr = Thread.new do |thr|
+          resp = stub.watch("foo", nil, 1, nil)
+        end
+        sleep 2
+        kv_stub.put("foo", "works")
+        thr.join
+        expect(resp).to be_an_instance_of(Google::Protobuf::RepeatedField)
+        expect(resp.last.kv.key).to eq('foo')  
       end
-      it_should_behave_like "a method with a GRPC timeout", described_class, :watch, :watch, 'foo', "\0", 1, nil
     end
   end
 end

data/spec/etcdv3_spec.rb

@@ -521,5 +521,261 @@ describe Etcdv3 do
         end
       end
     end
+
+    describe "namespace" do 
+
+      describe '#get' do
+        let(:get_conn) { local_connection_with_namespace("/namespace-get/") }
+
+        before do
+          conn.put('/apples/', 'app')
+          conn.put('/namespace-get/apple', 'apple')
+          conn.put('/namespace-get/apples', 'apples')
+          conn.put('/namespace-get/appless', 'appless')
+        end
+
+        it 'returns key w/o namespace' do 
+          expect(get_conn.get("apple").kvs.last.value).to eq('apple')
+        end
+
+        it 'returns keys w/o namespace' do 
+          expect(get_conn.get("apple", range_end: 'applf').kvs.size).to eq(3)
+        end
+
+        it 'returns all keys under namespace' do 
+          expect(get_conn.get("", range_end: "\0").kvs.size).to eq(3)
+        end
+      end
+
+      describe '#put' do
+        let(:put_conn) { local_connection_with_namespace("/namespace-put/") }
+
+        before do
+          put_conn.put('apple_put', 'test')
+        end
+        it 'returns key with namespace' do 
+          expect(conn.get("/namespace-put/apple_put").kvs.last.value).to eq('test')
+        end
+      end
+
+      describe '#del' do 
+        let(:del_conn) { local_connection_with_namespace("/del-test/") }
+        
+        context 'zero-byte' do 
+          before do 
+            del_conn.put('test', "key")
+            del_conn.put('test2', "key2")
+            conn.put('wall', 'zzzz')
+            conn.put('walzz', 'adsfas')
+          end
+
+          it 'deleting all keys should be scoped to namespace' do 
+            resp = del_conn.del("", range_end: "\0")
+            expect(resp.deleted).to eq(2)
+            expect(conn.get("wall").kvs.last.value).to eq('zzzz')
+          end
+        end
+
+        context 'no range' do
+          before { del_conn.put('test', 'value') }
+          subject { del_conn.del('test') }
+          it { is_expected.to_not be_nil }
+        end
+
+        context 'ranged del' do
+          before do
+            del_conn.put('test', 'value')
+            del_conn.put('testt', 'value')
+          end
+          subject { del_conn.del('test', range_end: 'testtt') }
+          it { is_expected.to_not be_nil }
+        end
+      end
+
+      describe '#transaction' do
+        let(:trans_conn) { local_connection_with_namespace("/namespace/") }
+
+        describe 'txn.value' do
+          before { trans_conn.put('txn', 'value') }
+          after { trans_conn.del('txn') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.value('txn', :equal, 'value') ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(conn.get("/namespace/txn-test").kvs.first.value).to eq('success')
+            end
+            it "raises a GRPC::DeadlineExceeded exception when it takes too long"  do
+              expect do
+                trans_conn.transaction(timeout: 0) do |txn|
+                  txn.compare = [ txn.value('txn', :equal, 'value') ]
+                  txn.success = [ txn.put('txn-test', 'success') ]
+                  txn.failure = [ txn.put('txn-test', 'failed') ]
+                end
+              end.to raise_exception(GRPC::DeadlineExceeded)
+            end
+            it "accepts a timeout" do
+              expect do
+                trans_conn.transaction(timeout: 1) do |txn|
+                  txn.compare = [ txn.value('txn', :equal, 'value') ]
+                  txn.success = [ txn.put('txn-test', 'success') ]
+                  txn.failure = [ txn.put('txn-test', 'failed') ]
+                end
+              end.to_not raise_exception
+            end
+          end
+          context "success, value with lease" do
+            let!(:lease_id) { trans_conn.lease_grant(2)['ID'] }
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.value('txn', :equal, 'value') ]
+                txn.success = [ txn.put('txn-test', 'success', lease_id) ]
+                txn.failure = [ txn.put('txn-test', 'failed', lease_id) ]
+              end
+            end
+            it 'sets correct key, with a lease' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(trans_conn.get('txn-test').kvs.first.lease).to eq(lease_id)
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.value('txn', :equal, 'notright') ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+            end
+          end
+        end
+  
+        describe 'txn.create_revision' do
+          before { trans_conn.put('txn', 'value') }
+          after { trans_conn.del('txn') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.create_revision('txn', :greater, 1) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.create_revision('txn', :equal, 1) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('failed')
+            end
+          end
+        end
+  
+        describe 'txn.mod_revision' do
+          before { trans_conn.put('txn', 'value') }
+          after { trans_conn.del('txn') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.mod_revision('txn', :less, 1000) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('success')
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.mod_revision('txn', :greater, 1000) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('failed')
+
+            end
+          end
+        end
+  
+        describe 'txn.version' do
+          before { trans_conn.put('txn-version', 'value') }
+          after { trans_conn.del('txn-version') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.version('txn-version', :equal, 1) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('success')
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.version('txn', :equal, 100)]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('failed')
+            end
+          end
+        end
+      end
+
+      # Locking is not implemented in etcd v3.1.X
+      unless $instance.version < Gem::Version.new("3.2.0")
+        describe "locking" do 
+          let(:ns_conn) { local_connection_with_namespace("/namespace/") }
+
+          describe '#lock' do
+            let(:lease_id) { lease_stub.lease_grant(10)['ID'] }
+            subject { ns_conn.lock('mylocklock', lease_id) }
+            it 'should lock key under specified namespace' do 
+              expect(conn.get("/namespace/#{subject.key}").kvs).to_not be_empty
+            end
+          end
+
+          describe '#with_lock' do
+            let(:lease_id) { lease_stub.lease_grant(10)['ID'] }
+            let(:lease_id_2) { lease_stub.lease_grant(15)['ID'] }
+            it 'enforces lock' do
+              ns_conn.with_lock('mylock', lease_id) do
+                expect { ns_conn.lock('mylock', lease_id_2, timeout: 0.1) }
+                  .to raise_error(GRPC::DeadlineExceeded)
+              end
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/helpers/connections.rb

@@ -5,18 +5,26 @@ module Helpers
       Etcdv3.new(endpoints: "http://#{local_url}", user: user, password: password)
     end
 
-    def local_connection(endpoints="http://#{local_url}")
-      Etcdv3.new(endpoints: endpoints)
+    def local_connection(endpoints="http://#{local_url}", allow_reconnect: true)
+      Etcdv3.new(endpoints: endpoints, allow_reconnect: allow_reconnect)
     end
 
     def local_connection_with_timeout(timeout)
       Etcdv3.new(endpoints: "http://#{local_url}", command_timeout: timeout)
     end
 
+    def local_connection_with_namespace(namespace)
+      Etcdv3.new(endpoints: "http://#{local_url}", namespace: namespace)
+    end
+
     def local_stub(interface, timeout=nil)
       interface.new(local_url, :this_channel_is_insecure, timeout, {})
     end
 
+    def local_namespace_stub(interface, timeout=nil, namespace)
+      interface.new(local_url, :this_channel_is_insecure, timeout, namespace, {})
+    end
+
     def local_url
       "127.0.0.1:#{port}"
     end

data/spec/spec_helper.rb

@@ -1,10 +1,12 @@
 $LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift File.expand_path('./helpers', __FILE__)
+$LOAD_PATH.unshift File.expand_path('./namespace', __FILE__)
 
-require 'simplecov'
-require 'codecov'
-SimpleCov.start
-SimpleCov.formatter = SimpleCov::Formatter::Codecov
+
+# require 'simplecov'
+# require 'codecov'
+# SimpleCov.start
+# SimpleCov.formatter = SimpleCov::Formatter::Codecov
 
 require 'etcdv3'
 require 'helpers/test_instance'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etcdv3
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.3
 platform: ruby
 authors:
 - Shaun Davis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-29 00:00:00.000000000 Z
+date: 2021-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grpc
@@ -97,6 +97,12 @@ files:
 - lib/etcdv3/lease.rb
 - lib/etcdv3/lock.rb
 - lib/etcdv3/maintenance.rb
+- lib/etcdv3/namespace/kv.rb
+- lib/etcdv3/namespace/kv/requests.rb
+- lib/etcdv3/namespace/kv/transaction.rb
+- lib/etcdv3/namespace/lock.rb
+- lib/etcdv3/namespace/utilities.rb
+- lib/etcdv3/namespace/watch.rb
 - lib/etcdv3/protos/annotations.proto
 - lib/etcdv3/protos/auth.proto
 - lib/etcdv3/protos/descriptor.proto
@@ -114,6 +120,9 @@ files:
 - spec/etcdv3/lease_spec.rb
 - spec/etcdv3/lock_spec.rb
 - spec/etcdv3/maintenance_spec.rb
+- spec/etcdv3/namespace/kv_spec.rb
+- spec/etcdv3/namespace/lock_spec.rb
+- spec/etcdv3/namespace/watch_spec.rb
 - spec/etcdv3/watch_spec.rb
 - spec/etcdv3_spec.rb
 - spec/helpers/connections.rb
@@ -139,8 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 3.2.20
 signing_key: 
 specification_version: 4
 summary: A Etcd client library for Version 3
@@ -152,6 +160,9 @@ test_files:
 - spec/etcdv3/lease_spec.rb
 - spec/etcdv3/lock_spec.rb
 - spec/etcdv3/maintenance_spec.rb
+- spec/etcdv3/namespace/kv_spec.rb
+- spec/etcdv3/namespace/lock_spec.rb
+- spec/etcdv3/namespace/watch_spec.rb
 - spec/etcdv3/watch_spec.rb
 - spec/etcdv3_spec.rb
 - spec/helpers/connections.rb