libcouchbase 0.0.1

data/lib/libcouchbase/version.rb

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

data/libcouchbase.gemspec

@@ -0,0 +1,61 @@
+require File.expand_path("../lib/libcouchbase/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "libcouchbase"
+    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.0.1', '< 4'
+
+    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")
+
+    # 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
+end

data/spec/bucket_spec.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+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
+
+    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 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

data/spec/connection_spec.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'libcouchbase'
+
+
+describe Libcouchbase::Connection do
+    before :each do
+        @log = []
+        expect(@log).to eq([])
+        @reactor = ::Libuv::Reactor.default
+    end
+
+    it "should connect and disconnect from the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then {
+                @log << true
+            }.finally { connection.destroy }
+        }
+
+        expect(@log).to eq([true])
+    end
+
+    it "should store a raw key on the bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('sometestkey', 'rawdata', format: :plain).then(proc {|resp|
+                    @log << resp.callback
+                    prom = connection.store('sometestkey', 'moredata', operation: :append)
+                    prom.then(proc { |success|
+                        connection.get('sometestkey').then(proc {|resp|
+                            @log << resp.value
+                        }, proc { |error|
+                            @log << error
+                        })
+                    }, proc { |error|
+                        @log << error
+                    })
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_store, 'rawdatamoredata'])
+    end
+
+    it "should store a key on the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('sometestkey', {"json" => "data"}).then(proc {|resp|
+                    @log << resp.callback
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_store])
+    end
+
+    it "should durably store a key on the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('sometestkey', {"json" => "data2"}, persist_to: -1, replicate_to: -1).then(proc {|resp|
+                    @log << resp.callback
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_storedur])
+    end
+
+    it "should fetch a key from the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.get('sometestkey').then(proc {|resp|
+                    @log << resp.value
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([{json: "data2"}])
+    end
+
+    it "should unlock a key on the default bucket" do
+
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.get('sometestkey', lock: 2).then(proc {|resp|
+                    @log << resp.callback
+                    connection.unlock('sometestkey', cas: resp.cas).then(proc {|resp|
+                        @log << resp.callback
+                    }, proc { |error|
+                        @log << error
+                    })
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:callback_get, :callback_unlock])
+    end
+
+    it "should remove a key on the default bucket" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.remove('sometestkey').then(proc {|resp|
+                    @log << :success
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([:success])
+    end
+
+    it "should allow settings to be configured" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                expect(co(connection.configure(:operation_timeout, 1500000))).to be(connection)
+                expect { co(connection.configure(:bob, 1500000)) }.to raise_error(Libcouchbase::Error)
+                @log << :success
+                connection.destroy
+            end
+        }
+
+        expect(@log).to eq([:success])
+    end
+
+    it "should return the server list" do
+        @reactor.run { |reactor|
+            begin
+                connection = Libcouchbase::Connection.new
+                co connection.connect
+                @log = co(connection.get_server_list)
+            ensure
+                connection.destroy
+            end
+        }
+
+        expect(@log).to eq(['127.0.0.1:8091'])
+    end
+
+    it "should support counter operations" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.counter('testcount', initial: 10, expire_in: 2)
+                .then(proc { |resp|
+                    @log << resp.value
+                    connection.get('testcount').then do |resp|
+                        @log << resp.value
+                    end
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([10, 10])
+    end
+
+    it "should support touch operations" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.store('testtouch', 34).then(proc {|resp|
+                    @log << resp.value
+                    connection.touch('testtouch', expire_in: 1).then(proc {
+                        @log << 'set'
+                        sleep 2
+                        connection.get('testtouch').catch(proc {|err|
+                            @log << err.is_a?(Libcouchbase::Error::KeyNotFound)
+                        })
+                    })
+                }, proc { |error|
+                    @log << error
+                }).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([34, 'set', true])
+    end
+
+    it "should fail to flush unless the connection specifies it is enabled" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                begin
+                    connection.flush.then(proc {
+                        @log << :error
+                    }, proc {
+                        @log << :error
+                    }).finally { connection.destroy }
+                rescue => e
+                    @log << :success
+                    connection.destroy
+                end
+            end
+        }
+
+        expect(@log).to eq([:success])
+    end
+
+    it "should flush when enabled explicitly" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new(bucket: :test, password: 'password123')
+            connection.connect(flush_enabled: true).then do
+                begin
+                    connection.flush.then(proc { |resp|
+                        @log << resp.callback
+                    }, proc { |error|
+                        @log << error
+                    }).finally { connection.destroy }
+                rescue => e
+                    @log << e
+                    connection.destroy
+                end
+            end
+        }
+
+        expect(@log).to eq([:callback_cbflush])
+    end
+
+    it "should perform a HTTP request" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.http("/pools/default/buckets/#{connection.bucket}/ddocs", type: :management).then(
+                    proc { |resp|
+                        @log << resp.headers.empty?
+                        @log << resp.body.empty?
+                    },
+                    proc { |err|
+                        @log << err
+                    }
+                ).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq([false, false])
+    end
+
+    it "should fail a HTTP request" do
+        @reactor.run { |reactor|
+            connection = Libcouchbase::Connection.new
+            connection.connect.then do
+                connection.http("/pools/default/buckets/#{connection.bucket}/ddocs").then(
+                    proc { |resp|
+                        @log << resp.headers.empty?
+                        @log << resp.body.empty?
+                    },
+                    proc { |err|
+                        @log << err.message
+                        @log << err.code
+                    }
+                ).finally { connection.destroy }
+            end
+        }
+
+        expect(@log).to eq(['non success response for /pools/default/buckets/default/ddocs', 400])
+    end
+end