kt 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e51d9769475943af5267c8d3e9cf7497bc4830dd
+  data.tar.gz: d9d0385cec3ed60994fe58af7796b946ae8ac4c7
+SHA512:
+  metadata.gz: 86663c41ca8c8a04c7db442d41a2fead8446a1d016f803ca379d62f9b110c20a4b209c113c1c907c40e47d665de812183f3ebf25616f70694ce1765107735eca
+  data.tar.gz: 26c05b1d767681bcdd70603d006b8ec9874560f5b9bdf34a2b315bdba875e1552af3043af2c09dda784000d620446759996c1a833a7815d2d64481e14a71c4c0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+Gemfile.lock
+
+*.swp
+*.swo

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+rvm:
+  - "2.3.0"
+  - "2.2"
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install zlib1g-dev curl liblzo2-dev liblua5.1-0-dev -qq
+  - gem install bundler
+install:
+  # Cabinet
+  - pushd /tmp
+  - git clone https://github.com/alticelabs/kyoto.git
+  - pushd kyoto
+  - sudo make install --quiet
+  - popd
+  - popd
+  - sudo ldconfig
+script:
+  - bundle install
+  - rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kt.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright [2016] Kuende
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,71 @@
+# kt-ruby
+
+[![Build Status](https://travis-ci.org/kuende/kt-ruby.svg)](https://travis-ci.org/kuende/kt-ruby)
+
+Ruby client for [Kyoto Tycoon](http://fallabs.com/kyototycoon/). It uses a connection pool to maintain multiple connections.
+
+## Installation
+
+
+Add this to your application's `Gemfile`:
+
+```ruby
+gem 'kt'
+```
+
+
+## Usage
+
+```ruby
+require "kt"
+
+kt = KT.new(host: "127.0.0.1", port: 1978, poolsize: 5, timeout: 5.0)
+
+# Setting
+kt.set("japan", "tokyo") # set a key
+kt.set("japan", "tokyo", expire: 60) # set a key with expire of 60 seconds
+kt.set_bulk({"china" => "beijing", "france" => "paris", "uk" => "london"})
+
+kt.get("japan") # => "tokyo"
+kt.get_bulk(["japan", "france"]) # => {"japan" => "tokyo", "france" => "paris"}
+kt.get("foo") # => nil
+kt.get!("foo") # => raises KT::RecordNotFound
+
+kt.remove("japan") # => true
+kt.remove("japan") # => false, key japan is not found anymore
+kt.remove!("japan") # => raises KT::RecordNotFound becouse key japan is not found
+kt.remove_bulk(["japan", "china"]) # => 1 (number keys deleted)
+
+kt.clear # deletes all records in the database
+kt.vacuum # triggers forced garbage collection of expired records
+
+kt.set_bulk({"user:1" => "1", "user:2" => "2", "user:4" => "4"})
+kt.match_prefix("user:") # => ["user:1", "user:2", "user:3", "user:4", "user:5"]
+
+# Compare and swap
+kt.set("user:1", "1")
+kt.cas("user:1", "1", "2") # => true
+kt.cas("user:1", "1", "3") # => false, previous value is "2"
+kt.cas("user:1", nil, "3") # => false, record already exists with value "2"
+kt.cas("user:2", nil, "1") # => true, no record exists so it was set
+kt.cas("user:1", "2", nil) # => true, record is removed becouse it was present
+kt.cas("user:1", "2", nil) # => false, it fails becouse no record with this key exists
+
+# cas! raises where cas returns false
+kt.cas!("user:1", "1", "2") # => KT::CASFailed, no record exists with this value
+
+kt.count # => 2 keys in database
+```
+
+### TODO
+
+- [ ] implement expiration for most commands
+- [ ] work with multiple servers
+
+## Contributing
+
+1. Fork it ( https://github.com/kuende/kt-ruby/fork )
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/kt.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kt"
+  spec.version       = KT::VERSION
+  spec.authors       = ["Teodor Pripoae"]
+  spec.email         = ["toni@kuende.com"]
+  spec.description   = %q{Kyoto Tycoon client}
+  spec.summary       = %q{Kyoto Tycoon client for ruby. For more information see the Readme on github}
+  spec.homepage      = "https://github.com/kuende/kt-ruby"
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "excon", "~> 0.51.0"
+  spec.add_dependency "connection_pool", "~> 2.2"
+
+  # testing
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "rspec-eventually", "~> 0.1"
+  spec.add_development_dependency "pry", "~> 0.10"
+end

data/lib/kt.rb

@@ -0,0 +1,362 @@
+require "excon"
+require "connection_pool"
+require "base64"
+require "kt/errors"
+require "kt/kv"
+require "kt/version"
+
+class KT
+  IDENTITY_ENCODING = "text/tab-separated-values"
+  BASE64_ENCODING   = "text/tab-separated-values; colenc=B"
+
+  IDENTITY_HEADERS = {"Content-Type" => IDENTITY_ENCODING}
+  BASE64_HEADERS   = {"Content-Type" => BASE64_ENCODING}
+  EMPTY_HEADERS    = {}
+
+  def initialize(options)
+    @host = options.fetch(:host, "127.0.0.1")
+    @port = options.fetch(:port, 1978)
+    @poolsize = options.fetch(:poolsize, 5)
+    @timeout = options.fetch(:timeout, 5.0)
+
+    @pool = ConnectionPool.new(size: @poolsize, timeout: @timeout) do
+      Excon.new("http://#{@host}:#{@port}")
+    end
+  end
+
+  # count returns the number of records in the database
+  def count
+    status, m = do_rpc("/rpc/status")
+
+    if status != 200
+      raise_error(m)
+    end
+
+    find_rec(m, "count").value.to_i
+  end
+
+  # clear removes all records in the database
+  def clear
+    status, m = do_rpc("/rpc/clear")
+
+    if status != 200
+      raise_error(m)
+    end
+  end
+
+  # vacuum triggers garbage collection of expired records
+  def vacuum
+    status, m = do_rpc("/rpc/vacuum")
+
+    if status != 200
+      raise_error(m)
+    end
+  end
+
+  # get retrieves the data stored at key.
+  # It returns nil if no such data is found
+  def get(key)
+    status, body = do_rest("GET", key, nil)
+
+    case status
+    when 200
+      body
+    when 404
+      nil
+    end
+  end
+
+  # get! retrieves the data stored at key.
+  # KT::RecordNotFound is raised if not such data is found
+  def get!(key)
+    value = get(key)
+    if value != nil
+      value
+    else
+      raise KT::RecordNotFound.new("Key: #{key} not found")
+    end
+  end
+
+  # get_bulk retrieves the keys in the list
+  # It returns a hash of key => value.
+  # If a key was not found in the database, the value in return hash will be nil
+  def get_bulk(keys)
+    req = keys.map do |key|
+      KT::KV.new("_#{key}", "")
+    end
+
+    status, res_body = do_rpc("/rpc/get_bulk", req)
+
+    if status != 200
+      raise_error(res_body)
+    end
+
+    res = {}
+
+    res_body.each do |kv|
+      if kv.key.start_with?('_')
+        res[kv.key[1, kv.key.size - 1]] = kv.value
+      end
+    end
+
+    return res
+  end
+
+  # set stores the data at key
+  def set(key, value, expire: nil)
+    req = [
+      KT::KV.new("key", key),
+      KT::KV.new("value", value),
+    ]
+
+    if expire
+      req << KT::KV.new("xt", expire.to_s)
+    end
+
+    status, body = do_rpc("/rpc/set", req)
+
+    if status != 200
+      raise_error(body)
+    end
+  end
+
+  # set_bulk sets multiple keys to multiple values
+  def set_bulk(values)
+    req = values.map do |key, value|
+      KT::KV.new("_#{key}", value)
+    end
+
+    status, body = do_rpc("/rpc/set_bulk", req)
+
+    if status != 200
+      raise_error(body)
+    end
+
+    find_rec(body, "num").value.to_i
+  end
+
+  # remove deletes the data at key in the database.
+  def remove(key)
+    status, body = do_rest("DELETE", key, nil)
+
+    if status == 404
+      return false
+    end
+
+    if status != 204
+      raise KT::Error.new(body)
+    end
+
+    return true
+  end
+
+  # remove! deletes the data at key in the database
+  # it raises KT::RecordNotFound if key was not found
+  def remove!(key)
+    unless remove(key)
+      raise KT::RecordNotFound.new("key #{key} was not found")
+    end
+  end
+
+  # remove_bulk deletes multiple keys.
+  # it returnes the number of keys deleted
+  def remove_bulk(keys)
+    req = keys.map do |key|
+      KV.new("_#{key}", "")
+    end
+
+    status, body = do_rpc("/rpc/remove_bulk", req)
+
+    if status != 200
+      raise_error(body)
+    end
+
+    find_rec(body, "num").value.to_i
+  end
+
+  # match_prefix performs the match_prefix operation against the server
+  # It returns a sorted list of keys.
+  # max_records defines the number of results to be returned
+  # if negative, it means unlimited
+  def match_prefix(prefix, max_records = -1)
+    req = [
+      KT::KV.new("prefix", prefix),
+      KT::KV.new("max", max_records.to_s)
+    ]
+
+    status, body = do_rpc("/rpc/match_prefix", req)
+
+    if status != 200
+      raise_error(body)
+    end
+
+    res = []
+
+    body.each do |kv|
+      if kv.key.start_with?('_')
+        res << kv.key[1, kv.key.size - 1]
+      end
+    end
+
+    return res
+  end
+
+  # cas executes a compare and swap operation
+  # if both old and new provided it sets to new value if previous value is old value
+  # if no old value provided it will set to new value if key is not present in db
+  # if no new value provided it will remove the record if it exists
+  # it returns true if it succeded or false otherwise
+  def cas(key, oval = nil, nval = nil)
+    req = [KT::KV.new("key", key)]
+    if oval != nil
+      req << KT::KV.new("oval", oval)
+    end
+    if nval != nil
+      req << KT::KV.new("nval", nval)
+    end
+
+    status, body = do_rpc("/rpc/cas", req)
+
+    if status == 450
+      return false
+    end
+
+    if status != 200
+      raise_error(body)
+    end
+
+    return true
+  end
+
+  # cas! works the same as cas but it raises error on failure
+  def cas!(key, oval = nil, nval = nil)
+    if !cas(key, oval, nval)
+      raise KT::CASFailed.new("Failed compare and swap for #{key}")
+    end
+  end
+
+  private
+
+  def do_rpc(path, values=nil)
+    body, encoding = encode_values(values)
+    headers = {"Content-Type" => encoding}
+
+    @pool.with do |conn|
+      res = conn.post(:path => path, :headers => headers, :body => body)
+      # return res.status_code, decode_values(res.body, res.headers.get("Content-Type").join("; "))
+      return res.status, decode_values(res.body, res.headers["Content-Type"])
+    end
+  end
+
+  def do_rest(method, key, value="")
+    @pool.with do |conn|
+      res = conn.request(:method => method, :path => url_encode(key), :headers => EMPTY_HEADERS, :body => value)
+      return res.status, res.body
+    end
+  end
+
+  def find_rec(kv_list, key)
+    kv_list.each do |kv|
+      if kv.key == key
+        return kv
+      end
+    end
+
+    KV.new("", "")
+  end
+
+  def raise_error(body)
+    kv = find_rec(body, "ERROR")
+    if kv == ""
+      raise KT::Error.new("unknown error")
+    end
+
+    raise KT::Error.new("#{kv.value}")
+  end
+
+  def decode_values(body, content_type)
+    # Ideally, we should parse the mime media type here,
+    # but this is an expensive operation because mime is just
+    # that awful.
+    #
+    # KT responses are pretty simple and we can rely
+    # on it putting the parameter of colenc=[BU] at
+    # the end of the string. Just look for B, U or s
+    # (last character of tab-separated-values)
+    # to figure out which field encoding is used.
+
+    case content_type.chars.last
+    when 'B'
+      # base64 decode
+      method = :base64_decode
+    when 'U'
+      # url decode
+      method = :url_decode
+    when 's'
+      # identity decode
+      method = :identity_decode
+    else
+      raise "kt responded with unknown content-type: #{content_type}"
+    end
+
+    # Because of the encoding, we can tell how many records there
+    # are by scanning through the input and counting the \n's
+    kv = body.each_line.map do |line|
+      key, value = line.chomp.split("\t")
+      KT::KV.new(send(method, key), send(method, value))
+    end.to_a
+
+    kv.to_a
+  end
+
+  def encode_values(kv_list)
+    if kv_list.nil?
+      return "", IDENTITY_ENCODING
+    end
+
+    has_binary = kv_list.any? do |kv|
+      has_binary?(kv.key) || has_binary?(kv.value)
+    end
+
+    str = StringIO.new
+
+    kv_list.each do |kv|
+      if has_binary
+        str << Base64.strict_encode64(kv.key)
+        str << "\t"
+        str << Base64.strict_encode64(kv.value)
+      else
+        str << kv.key
+        str << "\t"
+        str << kv.value
+      end
+      str << "\n"
+    end
+
+    encoding = has_binary ? BASE64_ENCODING : IDENTITY_ENCODING
+
+    return str.string, encoding
+  end
+
+  def identity_decode(value)
+    value.force_encoding("utf-8")
+  end
+
+  def base64_decode(value)
+    Base64.strict_decode64(value).force_encoding("utf-8")
+  end
+
+  def url_decode(value)
+    URI.unescape(value).force_encoding("utf-8")
+  end
+
+  def url_encode(key)
+    "/" + URI.escape(key).gsub("/", "%2F")
+  end
+
+  def has_binary?(value)
+    value.bytes.any? do |c|
+      c < 0x20 || c > 0x7e
+    end
+  end
+end

data/lib/kt/errors.rb

@@ -0,0 +1,10 @@
+class KT
+  class RecordNotFound < StandardError
+  end
+
+  class Error < StandardError
+  end
+
+  class CASFailed < StandardError
+  end
+end

data/lib/kt/kv.rb

@@ -0,0 +1,10 @@
+class KT
+  class KV
+    attr_accessor :key, :value
+
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+  end
+end

data/lib/kt/version.rb

@@ -0,0 +1,3 @@
+class KT
+  VERSION = "0.1.1"
+end

data/spec/kt_spec.rb

@@ -0,0 +1,221 @@
+# encoding: UTF-8
+
+require "spec_helper"
+
+describe KT do
+  before :all do
+    @kt = KT.new(host: HOST, port: PORT, poolsize: 5, timeout: 5.0)
+  end
+
+  after :all do
+    @kt.clear
+  end
+
+  describe "count" do
+    it "returns 0 by default" do
+      expect(@kt.count).to eql(0)
+    end
+
+    it "returns 2 after some keys were inserted" do
+      @kt.set("japan", "tokyo")
+      @kt.set("china", "beijing")
+
+      expect(@kt.count).to eql(2)
+    end
+  end
+
+  describe "get/set/remove" do
+    it "sets a few keys then it gets them" do
+      ["a", "b", "c"].each do |k|
+        @kt.set(k, k + "aaa")
+        expect(@kt.get(k)).to eql(k + "aaa")
+      end
+    end
+
+    it "removes a key" do
+      @kt.set("to/be/removed", "42")
+      @kt.remove("to/be/removed")
+      expect(@kt.get("to/be/removed")).to eql(nil)
+    end
+
+    it "get returns nil if not found" do
+      expect(@kt.get("not/existing")).to eql(nil)
+    end
+
+    describe "get!" do
+      it "returns a string if existing" do
+        @kt.set("foo", "bar")
+        expect(@kt.get("foo")).to eql("bar")
+      end
+
+      it "raises error if not found" do
+        expect {
+          @kt.get!("not/existing")
+        }.to raise_error(KT::RecordNotFound)
+      end
+    end
+
+    describe "remove" do
+      it "returns true if key was deleted" do
+        @kt.set("foo", "bar")
+        expect(@kt.remove("foo")).to eql(true)
+      end
+
+      it "returns false if key was not found" do
+        expect(@kt.remove("not/existing")).to eql(false)
+      end
+    end
+
+    describe "remove!" do
+      it "returns nothing if key was deleted" do
+        @kt.set("foo", "bar")
+        @kt.remove("foo")
+        expect(@kt.get("foo")).to eql(nil)
+      end
+
+      it "raises error if not found" do
+        expect {
+          @kt.remove!("not/existing")
+        }.to raise_error(KT::RecordNotFound)
+      end
+    end
+
+    describe "set" do
+      it "accepts expire" do
+        @kt.set("expirekey", "expiredvalue", expire: 1)
+        expect(@kt.get("expirekey")).to eql("expiredvalue")
+        @kt.vacuum # trigger garbage collection
+
+        expect {
+          @kt.get("expirekey")
+        }.to eventually(eq(nil)).within(5)
+      end
+    end
+  end
+
+  describe "bulk" do
+    it "returns nil hash for not found keys" do
+      expect(@kt.get_bulk(["foo1", "foo2", "foo3"])).to eql({})
+    end
+
+    it "returns hash with key value" do
+      expected = {
+        "cache/news/1" => "1",
+        "cache/news/2" => "2",
+        "cache/news/3" => "3",
+        "cache/news/4" => "4",
+        "cache/news/5" => "5",
+        "cache/news/6" => "6"
+      }
+      expected.each do |k, v|
+        @kt.set(k, v)
+      end
+
+      expect(@kt.get_bulk(expected.keys)).to eql(expected)
+    end
+
+    it "returns hash with found elements" do
+      @kt.set("foo4", "4")
+      @kt.set("foo5", "5")
+
+      expect(@kt.get_bulk(["foo4", "foo5", "foo6"])).to eql({"foo4" => "4", "foo5" => "5"})
+    end
+
+    it "set_bulk sets multiple keys" do
+      @kt.set_bulk({"foo7" => "7", "foo8" => "8", "foo9" => "9"})
+      expect(@kt.get_bulk(["foo7", "foo8", "foo9"])).to eql({"foo7" => "7", "foo8" => "8", "foo9" => "9"})
+    end
+
+    it "remove_bulk deletes bulk items" do
+      @kt.set_bulk({"foo7" => "7", "foo8" => "8", "foo9" => "9"})
+      @kt.remove_bulk(["foo7", "foo8", "foo9"])
+      expect(@kt.get_bulk(["foo7", "foo8", "foo9"])).to eql({})
+    end
+
+    it "returns the number of keys deleted" do
+      @kt.set_bulk({"foo7" => "7", "foo8" => "8", "foo9" => "9"})
+      expect(@kt.remove_bulk(["foo7", "foo8", "foo9", "foo1000"])).to eql(3)
+    end
+  end
+
+  describe "match_prefix" do
+    it "returns nothing for not found prefix" do
+      expect(@kt.match_prefix("user:", 100)).to eql([])
+    end
+
+    it "returns correct results sorted" do
+      @kt.set_bulk({"user:1" => "1", "user:2" => "2", "user:4" => "4"})
+      @kt.set_bulk({"user:3" => "3", "user:5" => "5"})
+      @kt.set_bulk({"usera" => "aaa", "users:bbb" => "bbb"})
+
+      expect(@kt.match_prefix("user:")).to eql(["user:1", "user:2", "user:3", "user:4", "user:5"])
+      # It returns the results in random order
+      expect(@kt.match_prefix("user:", 2).size).to eql(2)
+    end
+  end
+
+  describe "clear" do
+    it "clears the database" do
+      expect(@kt.count).to_not eql(0)
+      @kt.clear
+      expect(@kt.count).to eql(0)
+    end
+  end
+
+  describe "cas" do
+    describe "with old and new" do
+      it "sets new value if old value is correct and returns true" do
+        @kt.set("cas:1", "1")
+        expect(@kt.cas("cas:1", "1", "2")).to eql(true)
+        expect(@kt.get("cas:1")).to eql("2")
+      end
+
+      it "returns false if old value is not equal" do
+        @kt.set("cas:2", "3")
+        expect(@kt.cas("cas:2", "1", "2")).to eql(false)
+        expect(@kt.get("cas:2")).to eql("3")
+      end
+    end
+
+    describe "without old value" do
+      it "sets the value if no record exists in db and returns true" do
+        expect(@kt.cas("cas:3", nil, "5")).to eql(true)
+        expect(@kt.get("cas:3")).to eql("5")
+      end
+
+      it "returns false if record exists in db" do
+        @kt.set("cas:4", "2")
+        expect(@kt.cas("cas:4", nil, "5")).to eql(false)
+        expect(@kt.get("cas:4")).to eql("2")
+      end
+    end
+
+    describe "without new value" do
+      it "removes record if it exists in db and returns true" do
+        @kt.set("cas:5", "1")
+        expect(@kt.cas("cas:5", "1", nil)).to eql(true)
+        expect(@kt.get("cas:5")).to eql(nil)
+      end
+
+      it "returns false if no record exists in db" do
+        expect(@kt.cas("cas:6", "1", nil)).to eql(false)
+        expect(@kt.get("cas:6")).to eql(nil)
+      end
+    end
+  end
+
+  describe "binary" do
+    it "sets binary and gets it" do
+      @kt.set_bulk({"Café" => "foo"})
+      expect(@kt.get("Café")).to eql("foo")
+
+      @kt.set_bulk({"foo" => "Café"})
+      expect(@kt.get_bulk(["foo"])).to eql({"foo" => "Café"})
+    end
+
+    it "sets string using newlines and gets it" do
+      @kt.set_bulk({"foo" => "my\n\ttest"})
+      expect(@kt.get_bulk(["foo"])).to eql({"foo" => "my\n\ttest"})
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+require "rubygems"
+require "bundler/setup"
+
+require "kt"
+require "rspec/eventually"
+require "pry"
+require "open3"
+
+HOST = "127.0.0.1"
+PORT = 1979
+
+def start_server(host, port)
+  if server_connected?(host, port)
+    raise "Server already running on port #{port}"
+  end
+
+  args = ["ktserver", "-host", host, "-port", port.to_s]
+  stdin, stdout, stderr, wait_thr = Open3.popen3(*args)
+
+  50.times do
+    if server_connected?(host, port)
+      return wait_thr
+    end
+    sleep 0.05
+  end
+
+  raise "Server failed to start on port #{port}"
+end
+
+def stop_server(wait_thr)
+  Process.kill("KILL", wait_thr.pid)
+end
+
+def server_connected?(host, port)
+  begin
+    socket = TCPSocket.new(host, port)
+    # puts "Server connected"
+    return true
+  rescue => e
+    # puts "Server failed: #{e}"
+  ensure
+    socket.close unless socket.nil?
+  end
+
+  false
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    @server_thr = start_server(HOST, PORT)
+    unless @server_thr
+      raise "Failed to connect to server"
+    end
+  end
+
+  config.after(:suite) do
+    if @server_thr
+      stop_server(@server_thr)
+    end
+  end
+
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: kt
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Teodor Pripoae
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-eventually
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Kyoto Tycoon client
+email:
+- toni@kuende.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- kt.gemspec
+- lib/kt.rb
+- lib/kt/errors.rb
+- lib/kt/kv.rb
+- lib/kt/version.rb
+- spec/kt_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kuende/kt-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Kyoto Tycoon client for ruby. For more information see the Readme on github
+test_files:
+- spec/kt_spec.rb
+- spec/spec_helper.rb