libcouchbase-mapo 1.4.1

data/lib/libcouchbase/subdoc_request.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module Libcouchbase; end;
+class Libcouchbase::SubdocRequest
+
+    def initialize(key, quiet, bucket: nil, exec_opts: nil)
+        @key = key.to_s
+        raise ArgumentError.new("invalid document key #{key.inspect}") unless @key.length > 0
+        @refs = []
+        @mode = nil
+        @quiet = quiet
+        @specs = []
+        @ignore = []
+
+        @bucket = bucket
+        @exec_opts = exec_opts
+    end
+
+    attr_reader :mode, :key, :ignore
+
+    # Internal use only
+    def to_specs_array
+        return @mem if @mem # effectively freezes this object
+        number = @specs.length
+        @mem = FFI::MemoryPointer.new(::Libcouchbase::Ext::SDSPEC, number, false)
+        @specs.each_with_index do |spec, index|
+            struct_bytes = spec.to_ptr.get_bytes(0, ::Libcouchbase::Ext::SDSPEC.size) # (offset, length)
+            @mem[index].put_bytes(0, struct_bytes) # (offset, byte_string)
+        end
+        @specs = nil
+        [@mem, number]
+    end
+
+    # Internal use only
+    def free_memory
+        @refs = nil
+        @mem = nil
+    end
+
+    # When not used in block form
+    def execute!(**opts)
+        opts = @exec_opts.merge(opts)
+        @exec_opts = nil
+        bucket = @bucket
+        @bucket = nil
+        bucket.subdoc_execute!(self, **opts)
+    end
+
+
+    # =========
+    #  Lookups
+    # =========
+
+    [ :get, :exists, :get_count ].each do |cmd|
+        command = :"sdcmd_#{cmd}"
+        define_method cmd do |path, quiet: nil, **opts|
+            quiet = @quiet if quiet.nil?
+            new_spec(quiet, path, command, :lookup)
+            self
+        end
+    end
+    alias_method :exists?, :exists
+
+
+    # ===========
+    #  Mutations
+    # ===========
+
+    def remove(path, quiet: nil, **opts)
+        quiet = @quiet if quiet.nil?
+        new_spec(quiet, path, :sdcmd_remove, :mutate)
+        self
+    end
+
+    [
+        :dict_add, :dict_upsert, :array_add_first, :array_add_last, :array_add_unique, :counter
+    ].each do |cmd|
+        command = :"sdcmd_#{cmd}"
+        define_method cmd do |path, value, create_intermediates: true, **opts|
+            spec = new_spec(false, path, command, :mutate, create_intermediates)
+            set_value(spec, value)
+            self
+        end
+    end
+
+    [
+        :replace, :array_insert
+    ].each do |cmd|
+        command = :"sdcmd_#{cmd}"
+        define_method cmd do |path, value, **opts|
+            spec = new_spec(false, path, command, :mutate, false)
+            set_value(spec, value)
+            self
+        end
+    end
+
+
+    protected
+
+
+    # http://docs.couchbase.com/sdk-api/couchbase-c-client-2.8.2/group__lcb-subdoc.html#ga53e89dd6b480e81b82fb305d04d92e18
+    def new_spec(quiet, path, cmd, mode, create_intermediates = false)
+        @mode ||= mode
+        raise "unable to perform #{cmd} as mode is currently #{@mode}" if @mode != mode
+
+        spec = ::Libcouchbase::Ext::SDSPEC.new
+        spec[:sdcmd] = ::Libcouchbase::Ext::SUBDOCOP[cmd]
+        spec[:options] = ::Libcouchbase::Ext::SDSPEC::MKINTERMEDIATES if create_intermediates
+
+        loc = path.to_s
+        str = ref(loc)
+        spec[:path][:type] = :kv_copy
+        spec[:path][:contig][:bytes] = str
+        spec[:path][:contig][:nbytes] = loc.bytesize
+
+        @ignore << quiet
+        @specs << spec
+        spec
+    end
+
+    # http://docs.couchbase.com/sdk-api/couchbase-c-client-2.8.2/group__lcb-subdoc.html#ga61009762f6b23ae2a9685ddb888dc406
+    def set_value(spec, value)
+        # Create a JSON version of the value.
+        #  We throw it into an array so strings and numbers etc are valid, then we remove the array.
+        val = [value].to_json[1...-1]
+        str = ref(val)
+        spec[:value][:vtype] = :kv_copy
+        spec[:value][:u_buf][:contig][:bytes] = str
+        spec[:value][:u_buf][:contig][:nbytes] = val.bytesize
+        value
+    end
+
+    # We need to hold a reference to c-strings so they are not GC'd
+    def ref(string)
+        str = ::FFI::MemoryPointer.from_string(string)
+        @refs << str
+        str
+    end
+end

data/lib/libcouchbase/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module Libcouchbase
+    VERSION = '1.4.1'
+end

data/libcouchbase.gemspec

@@ -0,0 +1,68 @@
+require File.expand_path("../lib/libcouchbase/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "libcouchbase-mapo"
+    gem.version       = Libcouchbase::VERSION
+    gem.license       = 'MIT'
+    gem.authors       = ["Stephen von Takach"]
+    gem.email         = ["steve@cotag.me"]
+    gem.homepage      = "https://github.com/cotag/libcouchbase"
+    gem.summary       = "libcouchbase bindings for Ruby"
+    gem.description   = "A wrapper around libcouchbase for Ruby"
+
+    gem.extensions << "ext/Rakefile"
+
+    gem.required_ruby_version = '>= 2.1.0'
+    gem.require_paths = ["lib"]
+
+    gem.add_runtime_dependency     'ffi', '~> 1.9'
+    gem.add_runtime_dependency     'concurrent-ruby', '~> 1.0'
+    gem.add_runtime_dependency     'libuv', '>= 3.2.2', '< 5'
+
+    gem.add_development_dependency 'rake',         '~> 11.2'
+    gem.add_development_dependency 'rspec',        '~> 3.5'
+    gem.add_development_dependency 'yard',         '~> 0.9'
+    gem.add_development_dependency 'uv-rays',      '~> 2.0' # for libuv results spec
+    gem.add_development_dependency 'em-synchrony', '~> 1.0' # for eventmachine spec
+
+    # https://github.com/stakach/ffi-gen
+    # gem.add_development_dependency 'ffi-gen'
+
+    gem.files         = `git ls-files`.split("\n")
+    gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+    if File.exist? 'ext/libcouchbase.dll'
+        gem.files += ['ext/libcouchbase.dll', 'ext/libcouchbase_libuv.dll']
+    end
+
+    # Add the submodule to the gem
+    relative_path = File.expand_path("../", __FILE__) + '/'
+    `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+
+        if (ENV['OS'] == 'Windows_NT') && submodule_path[0] == '/'
+            # Detect if cygwin path is being used by git
+            submodule_path = submodule_path[1..-1]
+            submodule_path.insert(1, ':')
+        end
+
+        # for each submodule, change working directory to that submodule
+        Dir.chdir(submodule_path) do
+            # Make the submodule path relative
+            submodule_path = submodule_path.gsub(/#{relative_path}/i, '')
+
+            # issue git ls-files in submodule's directory
+            submodule_files = `git ls-files`.split($\)
+
+            # prepend the submodule path to create relative file paths
+            submodule_files_paths = submodule_files.map do |filename|
+                File.join(submodule_path, filename)
+            end
+
+            # add relative paths to gem.files
+            gem.files += submodule_files_paths
+        end
+    end
+
+    # Remove sym link (blows up on windows)
+    gem.files.delete('ext/libcouchbase/configure.pl')
+end

data/spec/bucket_spec.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+Libcouchbase::Defaults.username = 'tester'
+Libcouchbase::Defaults.password = 'password123'
+
+describe Libcouchbase::Bucket do
+    before :each do
+        # This will load the couchbase connection on a different thread
+        @bucket = Libcouchbase::Bucket.new
+        @reactor = ::Libuv::Reactor.default
+        @log = []
+    end
+
+    after :each do
+        @bucket = nil
+        @reactor = nil
+        @log = nil
+    end
+
+    describe 'reactor loop' do
+        it "should set a value" do
+            @reactor.run { |reactor|
+                result = @bucket.set('somekey', 'woop woop')
+                @log << result.key
+                @log << result.value
+                @log << @bucket.set('somekey2', 'woop woop2').value
+            }
+
+            expect(@log).to eq(['somekey', 'woop woop', 'woop woop2'])
+        end
+
+        it "should get a value" do
+            @reactor.run { |reactor|
+                @log << @bucket.get('somekey')
+                @log << @bucket.get('somekey', extended: true).value
+            }
+            expect(@log).to eq(['woop woop', 'woop woop'])
+        end
+
+        it "should get a value quietly" do
+            @reactor.run { |reactor|
+                @log << @bucket.get('somekey-noexist', quiet: true)
+                @log << @bucket[:noexist2]
+            }
+            expect(@log).to eq([nil, nil])
+        end
+
+        it "should get multiple values" do
+            @reactor.run { |reactor|
+                @log << @bucket.get('somekey', 'somekey2')
+                @log << @bucket.get('somekey', 'somekey2', 'no-exist-sgs', quiet: true)
+            }
+            expect(@log).to eq([['woop woop', 'woop woop2'], ['woop woop', 'woop woop2', nil]])
+        end
+
+        it "should get multiple values as a hash" do
+            @reactor.run { |reactor|
+                @log << @bucket.get('somekey', 'somekey2', assemble_hash: true)
+                @log << @bucket.get('somekey', 'somekey2', 'no-exist-sgs', quiet: true, assemble_hash: true)
+                @log << @bucket.get('somekey', assemble_hash: true)
+                @log << @bucket.get('no-exist-sgs', quiet: true, assemble_hash: true)
+            }
+            expect(@log).to eq([
+                {'somekey' => 'woop woop', 'somekey2' => 'woop woop2'},
+                {'somekey' => 'woop woop', 'somekey2' => 'woop woop2', 'no-exist-sgs' => nil},
+                {'somekey' => 'woop woop'},
+                {'no-exist-sgs' => nil}
+            ])
+        end
+
+        it "should compare and swap a value" do
+            @reactor.run { |reactor|
+                @bucket.set('somekey', 'woop woop')
+                result = @bucket.cas('somekey') do |current|
+                    @log << current
+                    "current #{current}"
+                end
+                @log << result.value
+            }
+            expect(@log).to eq(['woop woop', 'current woop woop'])
+        end
+
+        it "should fetch a value" do
+            @reactor.run { |reactor|
+                @bucket.delete('randomunknown')
+                @log << @bucket.fetch('randomunknown', 'woop woop')
+                @log << @bucket.fetch('randomunknown') { 'testing' }
+
+                @bucket.delete('otherunknown')
+                @log << @bucket.fetch('otherunknown') { 'testing' }
+                @log << @bucket.fetch('otherunknown', 'woop woop')
+            }
+            expect(@log).to eq(['woop woop', 'woop woop', 'testing', 'testing'])
+        end
+
+        it "should retry when performing a CAS operation" do
+            @reactor.run { |reactor|
+                begin
+                    @bucket.set('somekey', 'woop woop')
+                    result = @bucket.cas('somekey', retry: 2) do |current|
+                        @log << current
+                        # This ensures the operation fails
+                        @bucket.set('somekey', 'woop woop1')
+                        "current #{current}"
+                    end
+                    @log << result.value
+                rescue Libcouchbase::Error::KeyExists
+                    @log << :error
+                end
+            }
+            expect(@log).to eq(['woop woop', 'woop woop1', 'woop woop1', :error])
+        end
+    end
+
+    describe 'native ruby' do
+        it "should set a value" do
+            result = @bucket.set('somekey', 'woop woop')
+            @log << result.key
+            @log << result.value
+            @log << @bucket.set('somekey2', 'woop woop2').value
+
+            expect(@log).to eq(['somekey', 'woop woop', 'woop woop2'])
+        end
+
+        it "should get a value" do
+            @log << @bucket.get('somekey')
+            @log << @bucket.get('somekey', extended: true).value
+
+            expect(@log).to eq(['woop woop', 'woop woop'])
+        end
+
+        it "should get a value quietly" do
+            @log << @bucket.get('somekey-noexist', quiet: true)
+            @log << @bucket[:noexist2]
+
+            expect(@log).to eq([nil, nil])
+        end
+
+        it "should get multiple values" do
+            @log << @bucket.get('somekey', 'somekey2')
+            @log << @bucket.get('somekey', 'somekey2', 'no-exist-sgs', quiet: true)
+
+            expect(@log).to eq([['woop woop', 'woop woop2'], ['woop woop', 'woop woop2', nil]])
+        end
+
+        it "should get multiple values as a hash" do
+            @log << @bucket.get('somekey', 'somekey2', assemble_hash: true)
+            @log << @bucket.get('somekey', 'somekey2', 'no-exist-sgs', quiet: true, assemble_hash: true)
+            @log << @bucket.get('somekey', assemble_hash: true)
+            @log << @bucket.get('no-exist-sgs', quiet: true, assemble_hash: true)
+            
+            expect(@log).to eq([
+                {'somekey' => 'woop woop', 'somekey2' => 'woop woop2'},
+                {'somekey' => 'woop woop', 'somekey2' => 'woop woop2', 'no-exist-sgs' => nil},
+                {'somekey' => 'woop woop'},
+                {'no-exist-sgs' => nil}
+            ])
+        end
+
+        it "should get multiple results asynchronously and then wait for the results" do
+            results = []
+            results << @bucket.get('somekey', async: true)
+            results << @bucket.get('somekey2', async: true)
+            
+            @log = @bucket.wait_results results
+
+            expect(@log).to eq(['woop woop', 'woop woop2'])
+        end
+
+        it "should compare and swap a value" do
+            @bucket.set('somekey', 'woop woop')
+            result = @bucket.cas('somekey') do |current|
+                @log << current
+                "current #{current}"
+            end
+            @log << result.value
+
+            expect(@log).to eq(['woop woop', 'current woop woop'])
+        end
+
+        it "should retry when performing a CAS operation" do
+            begin
+                @bucket.set('somekey', 'woop woop')
+                result = @bucket.cas('somekey', retry: 2) do |current|
+                    @log << current
+                    # This ensures the operation fails
+                    @bucket.set('somekey', 'woop woop1')
+                    "current #{current}"
+                end
+                @log << result.value
+            rescue Libcouchbase::Error::KeyExists
+                @log << :error
+            end
+
+            expect(@log).to eq(['woop woop', 'woop woop1', 'woop woop1', :error])
+        end
+    end
+
+    describe 'eventmachine loop' do
+        require 'em-synchrony'
+
+        it "should set a value" do
+            EM.synchrony {
+                result = @bucket.set('somekey', 'woop woop')
+                @log << result.key
+                @log << result.value
+                @log << @bucket.set('somekey2', 'woop woop2').value
+                EM.stop
+            }
+
+            expect(@log).to eq(['somekey', 'woop woop', 'woop woop2'])
+        end
+
+        it "should get a value" do
+            EM.synchrony {
+                @log << @bucket.get('somekey')
+                @log << @bucket.get('somekey', extended: true).value
+                EM.stop
+            }
+            expect(@log).to eq(['woop woop', 'woop woop'])
+        end
+
+        it "should get a value quietly" do
+            EM.synchrony {
+                @log << @bucket.get('somekey-noexist', quiet: true)
+                @log << @bucket[:noexist2]
+                EM.stop
+            }
+            expect(@log).to eq([nil, nil])
+        end
+
+        it "should get multiple values" do
+            EM.synchrony {
+                @log << @bucket.get('somekey', 'somekey2')
+                @log << @bucket.get('somekey', 'somekey2', 'no-exist-sgs', quiet: true)
+                EM.stop
+            }
+            expect(@log).to eq([['woop woop', 'woop woop2'], ['woop woop', 'woop woop2', nil]])
+        end
+
+        it "should get multiple values as a hash" do
+            EM.synchrony {
+                @log << @bucket.get('somekey', 'somekey2', assemble_hash: true)
+                @log << @bucket.get('somekey', 'somekey2', 'no-exist-sgs', quiet: true, assemble_hash: true)
+                @log << @bucket.get('somekey', assemble_hash: true)
+                @log << @bucket.get('no-exist-sgs', quiet: true, assemble_hash: true)
+                EM.stop
+            }
+            expect(@log).to eq([
+                {'somekey' => 'woop woop', 'somekey2' => 'woop woop2'},
+                {'somekey' => 'woop woop', 'somekey2' => 'woop woop2', 'no-exist-sgs' => nil},
+                {'somekey' => 'woop woop'},
+                {'no-exist-sgs' => nil}
+            ])
+        end
+
+        it "should compare and swap a value" do
+            EM.synchrony {
+                @bucket.set('somekey', 'woop woop')
+                result = @bucket.cas('somekey') do |current|
+                    @log << current
+                    "current #{current}"
+                end
+                @log << result.value
+                EM.stop
+            }
+            expect(@log).to eq(['woop woop', 'current woop woop'])
+        end
+
+        it "should retry when performing a CAS operation" do
+            EM.synchrony {
+                begin
+                    @bucket.set('somekey', 'woop woop')
+                    result = @bucket.cas('somekey', retry: 2) do |current|
+                        @log << current
+                        # This ensures the operation fails
+                        @bucket.set('somekey', 'woop woop1')
+                        "current #{current}"
+                    end
+                    @log << result.value
+                rescue Libcouchbase::Error::KeyExists
+                    @log << :error
+                end
+                EM.stop
+            }
+            expect(@log).to eq(['woop woop', 'woop woop1', 'woop woop1', :error])
+        end
+    end
+end