etcdv3 0.10.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: db0142aa621e3ec4612d3d2051b06f208382001d
-  data.tar.gz: a1d300e69e53c41a9a3864d6d480011cc7ffc6a1
+SHA256:
+  metadata.gz: 59585a18eada27829edbf162733146e90e4c336bcbbefa761b3063e3f9400139
+  data.tar.gz: edc026da35b1396e664a431a79eb2012238ea4bd49c8ef43e1f70f93366935fe
 SHA512:
-  metadata.gz: 8cd28535b2f39b4b04d0d426b1bbf940997e512922ddc5da85a86d69cf0c24319b40a187d1cde576c5a01ad33f9ee470a33ea02f9fa2c442f6aaee0484b61d36
-  data.tar.gz: 3bb79400389240448d945e9b41b967cf4c4f65d1454bebdcaff4d8c60cbc82023b950e707f70c6bb87d89b0e3e13546eb64a05f1adcdf7356b0a75a35e0d3241
+  metadata.gz: d5afcdcad7f96e422bebcd6d4d4db148bbe48c8600be017650ae229d988cd2e5c6d3547f2026eb1db18a10c91643ba3e84bb0a2555b2f8add7f687dd9bfc014a
+  data.tar.gz: 310680f7f8f11b65dfb9ea1a116536394678faf05f29087a77b87b1665138f85c4bc39614299dff22a528a63f0a0771dbb3841e9b60a610611dacff33048fbf1

data/README.md

@@ -26,14 +26,16 @@ 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...
 
 ```
 **High Availability**
 
-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. That's the default
-behaviour.
+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
@@ -43,12 +45,29 @@ 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 new endpoint (since they were
-rotated) is tried. One thing you need to keep in mind if you are using etcd with
-authorization is that you need to take care of `GRPC::Unauthenticated` exceptions
-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.
+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/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,12 +3,13 @@ class Etcdv3
 
     attr_accessor :connection, :endpoints, :user, :password, :token, :timeout
 
-    def initialize(timeout, *endpoints, allow_reconnect)
+    def initialize(timeout, *endpoints, namespace, allow_reconnect)
       @user, @password, @token = nil, nil, nil
       @timeout = timeout
-      @endpoints = endpoints.map{|endpoint| Etcdv3::Connection.new(endpoint, @timeout) }
-      @connection = @endpoints.first
+      @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)
@@ -26,7 +27,6 @@ class Etcdv3
       $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 retry_or_raise(stub, method, method_args)
       else
         return retry_or_raise(stub, method, method_args)

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/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/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.2'.freeze
+  VERSION = '0.11.3'.freeze
 end

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'
@@ -24,9 +32,11 @@ class Etcdv3
   def initialize(**options)
     @options = options
     @timeout = options[:command_timeout] || DEFAULT_TIMEOUT
+    @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)

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,7 +3,7 @@ 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, true) }
+  subject { Etcdv3::ConnectionWrapper.new(10, *endpoints, nil, true) }
 
   describe '#initialize' do
     it { is_expected.to have_attributes(user: nil, password: nil, token: nil) }

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

@@ -13,10 +13,18 @@ module Helpers
       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.2
+  version: 0.11.3
 platform: ruby
 authors:
 - Shaun Davis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-15 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