handlersocket-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: acad8d994a34c1431708bfe35b8a1dc0fbf94597
+  data.tar.gz: cf8d34c2ad01ee30af626d70fc1bbfcd35a242da
+SHA512:
+  metadata.gz: 41b05acfa225c3adcb1b440eb12da25901ba0ff820ab3fe9f0225b0c5bb4d28d39a5aac74d1ff3004036e1ee8b8e464d03a7e86e98391b142fe86d0072e9761b
+  data.tar.gz: 5a8e4d2a8be4d0dae6b92bebf4aa1e56948e306c4e840bb5e020934695f288d6b0a77660152d31f799b535fe961fcd2a8a37b4e4ee797976759b69486d8517ce

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-version
+.ruby-gemset
+.rvmrc
+lib/handlersocket_ext.so
+.rspec
+mysql.yml
+handlersocket.yml

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+before_install: gem install bundler -v 1.10.6
+before_script:
+  - cp local_handlersocket.yml handlersocket.yml
+  - cp mysql.yml.sample mysql.yml
+  - bin/mock_hs_server > server_log &
+after_script:
+  - cat server_log
+rvm:
+  - 2.2.3
+  - 2.0.0
+env:
+  - HS_VERSION=pure
+  - HS_VERSION=ext

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in handlersocket.gemspec
+gemspec
+
+gem 'mysql2'
+gem 'benchmark-ips'
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ilya Bylich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,134 @@
+[![Build Status](https://travis-ci.org/iliabylich/handlersocket-ruby.svg?branch=master)](https://travis-ci.org/iliabylich/handlersocket-ruby)
+[![Code Climate](https://codeclimate.com/github/iliabylich/handlersocket-ruby/badges/gpa.svg)](https://codeclimate.com/github/iliabylich/handlersocket-ruby)
+
+# HandlerSocket
+
+Ruby/C -based zero dependency implementation of MySQL's HandlerSocket protocol.
+
+# What is HandlerSocket
+
+HandlerSocket is a NoSQL plugin for MySQL. It works as a daemon inside the mysqld process, accepting TCP connections, and executing requests from clients. HandlerSocket does not support SQL queries. Instead, it supports simple CRUD operations on tables.
+
+HandlerSocket can be much faster than mysqld/libmysql in some cases because it has lower CPU, disk, and network overhead:
+
+To lower CPU usage it does not parse SQL.
+Next, it batch-processes requests where possible, which further reduces CPU usage and lowers disk usage.
+Lastly, the client/server protocol is very compact compared to mysql/libmysql, which reduces network usage
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+# If you want to use Ruby-based implementation
+gem 'handlersocket-rb', require: 'handlersocket/pure'
+
+# If you want to use C-based implementation
+gem 'handlersocket-rb', require: 'handlersocket/ext'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install handlersocket-rb
+
+## Usage
+
+First of all, you need to install [handlersocket](http://yoshinorimatsunobu.blogspot.com.by/2010/10/using-mysql-as-nosql-story-for.html) plugin.
+
+If you are using Percona Server or MariaDB, you already have all necessary libraries.
+
+``` sql
+INSTALL PLUGIN handlersocket SONAME 'handlersocket.so';
+```
+
+And add the following code to mysql config file to `mysqld` section:
+```
+handlersocket_address="127.0.0.1"
+handlersocket_port="9998"
+handlersocket_port_wr="9999"
+```
+
+Reload MySQL server and run `show processlist;`. You should see a lot of connections from HandlerSocket.
+
+To create a connection to HandlerSocket run:
+``` ruby
+hs = Handlersocket.new('host', port)
+```
+
+To open an index run:
+``` ruby
+hs.open_index('0', 'hs_test', 'users', 'PRIMARY', ['id', 'email'])
+# where:
+# '0' - index name, you should pass it later to query method
+# 'hs_test' - database name
+# 'users' - table name
+# 'PRIMARY' - index name
+# ['id', 'name'] - columns that you want to read/write
+```
+
+To read the data run:
+``` ruby
+hs.find('0', '=', ['12'], ['100]'])
+# This query opens index '0' (primary index from the previous example)
+# and finds 100 rows with 'indexed value' = '12'
+# similar to
+# SELECT id, name FROM hs_test.users WHERE id = 12 LIMIT 100
+```
+
+## Benchmarks
+
+See `rake:benchmark`.
+
+```
+Calculating -------------------------------------
+             pure HS     2.000  i/100ms
+              ext HS     3.149k i/100ms
+              mysql2   669.000  i/100ms
+-------------------------------------------------
+             pure HS     49.979  (± 2.0%) i/s -    250.000
+              ext HS    110.369M (±15.7%) i/s -    467.793M
+              mysql2      5.218M (±16.3%) i/s -     23.869M
+
+Comparison:
+              ext HS: 110369437.2 i/s
+              mysql2:  5218120.6 i/s - 21.15x slower
+             pure HS:       50.0 i/s - 2208314.91x slower
+```
+
+Where:
++ `ext HS` is a C-based implementation of HandlerSocket protocol
++ `mysql2` is a default mysql2 adapter
++ `pure HS` is a Ruby-based implementation of HandlerSocket protocal
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Fill `handlersocket.yml` and `mysql.yml` in a root directory of the project.
+Run `rake test:db:create` to create a default database that is used in tests.
+Then, run `rake` to (re)compile the code and run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`,
+and then run `bundle exec rake release`,
+which will create a git tag for the version,
+push git commits and tags,
+and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Run `rake benchmark` to compare the performance of Ruby HS/C HS/Mysql2.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/iliabylich/handlersocket-ruby.
+This project is intended to be a safe, welcoming space for collaboration,
+and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,90 @@
+require "bundler/gem_tasks"
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('handlersocket_ext')
+
+require 'bundler/setup'
+require 'mysql2'
+mysql_config = YAML.load_file(File.expand_path('../mysql.yml', __FILE__))
+client = Mysql2::Client.new(mysql_config)
+
+namespace :test do
+  namespace :db do
+    desc 'Drops tests database'
+    task :drop do
+      client.query("DROP DATABASE IF EXISTS hs_test")
+    end
+
+    desc 'Prepares test database'
+    task :create do
+      client.query("CREATE DATABASE hs_test")
+      client.query("use hs_test")
+      client.query <<-SQL
+        CREATE TABLE users (
+          id int(11) NOT NULL AUTO_INCREMENT,
+          email varchar(255) NOT NULL DEFAULT '',
+          PRIMARY KEY (id)
+        )
+      SQL
+    end
+
+    desc 'Seeds test database'
+    task :seed do
+      count = ENV.fetch('SEED_COUNT', 100)
+      1.upto(count) do |i|
+        client.query("INSERT INTO users(email) VALUES ('email#{i}@email')")
+      end
+    end
+  end
+end
+
+desc 'Runs benchmark hs_pure/hs_ext/mysql2'
+task :benchmark do
+  mysql_config = YAML.load_file(File.expand_path('../mysql.yml', __FILE__))
+  hs_config    = YAML.load_file(File.expand_path('../handlersocket.yml', __FILE__))
+
+  require 'bundler/setup'
+  require 'benchmark/ips'
+
+  require 'handlersocket/pure'
+  class Handlersocket
+    alias_method :pure_query, :query
+    undef_method :query
+  end
+  pure_socket = Handlersocket.new(hs_config['host'], hs_config['port'])
+  pure_socket.pure_query(['P', '0', 'hs_test', 'users', 'PRIMARY', 'id', 'col'])
+
+  require 'handlersocket/ext'
+  class Handlersocket
+    alias_method :ext_query, :query
+    undef_method :query
+  end
+  ext_socket = Handlersocket.new(hs_config['host'], hs_config['port'])
+  ext_socket.ext_query(['P', '0', 'hs_test', 'users', 'PRIMARY', 'id', 'col'])
+
+  require 'mysql2'
+  mysql_client = Mysql2::Client.new(mysql_config)
+
+  Benchmark.ips do |x|
+    x.config time: 5, warmup: 2
+
+    x.report 'pure HS' do |times|
+      pure_socket.pure_query(['0', '=', '1', times.to_s, '100'])
+    end
+
+    x.report 'ext HS' do |times|
+      ext_socket.ext_query(['0', '=', '1', times.to_s, '100'])
+    end
+
+    x.report 'mysql2' do |times|
+      mysql_client.query("SELECT * FROM users where id = #{times} LIMIT 100").to_a
+    end
+
+    x.compare!
+  end
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:clobber, :compile, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "handlersocket"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/mock_hs_server

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+port = (ENV['HS_PORT'] || '9997').to_i
+server = TCPServer.new(port)
+puts "Server is running on 127.0.0.1:#{port}"
+
+REQ_RES = {
+  %w(P 0 hs_test users PRIMARY id,email) => %w(0 1),
+  %w(P 1 hs_test users PRIMARY id,email) => %w(0 1),
+  %w(P 2 missing-db missing-table missing-idx ) => %w(1 1 open_table),
+  %w(0 = 1 12 100) => %w(0 2 12 email12@email)
+}
+
+loop do
+  Thread.new(server.accept) do |client|
+    loop do
+      req = client.gets
+      if req
+        puts "[client=#{client.object_id} REQ] #{req.inspect}"
+        res = REQ_RES[req.chomp.split("\t")] || ["Unsupported"]
+        res = res.join("\t") + "\n"
+        puts "[client=#{client.object_id} RES] #{res.inspect}"
+        client.puts(res)
+      end
+    end
+  end
+end

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/handlersocket_ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('handlersocket_ext')

data/ext/handlersocket_ext/handlersocket_ext.c

@@ -0,0 +1,128 @@
+#include <stdio.h>
+#include <ruby.h>
+
+VALUE rb_Handlersocket;
+
+#ifndef RARRAY_AREF
+  #define RARRAY_AREF(ary,n) (RARRAY_PTR(ary)[n])
+#endif
+
+struct SocketData {
+  int socket_desc;
+  char* host;
+  int port;
+};
+typedef struct SocketData SOCKET_DATA;
+
+#include "socket/send.h"
+
+// A default destructor for a Handlersocket obejct that closes connection
+//
+// @param [Data] data
+// @see SocketData
+//
+static void hs_free(SOCKET_DATA *data) {
+  close(data->socket_desc);
+}
+
+// An allocator for a Handlersocket object
+//
+// @param [Handlersocket] hs
+//
+// @return [Data] SocketData
+//
+static VALUE hs_alloc(VALUE hs) {
+  SOCKET_DATA *data;
+  data = malloc(sizeof(SOCKET_DATA));
+  return Data_Wrap_Struct(hs, NULL, hs_free, data);
+}
+
+// Disconnects passed Handlersocket
+//
+// @param [Handlersocket] hs
+//
+static VALUE rb_hs_disconnect(VALUE hs) {
+  SOCKET_DATA *data;
+  Data_Get_Struct(hs, SOCKET_DATA, data);
+  hs_free(data);
+
+  return Qnil;
+}
+
+// Establishes a connection to HS server
+//
+// @param [Handlersocket] hs
+//
+// @return [nil]
+//
+static VALUE rb_hs_connect(VALUE hs) {
+  SOCKET_DATA *data;
+  struct sockaddr_in server;
+
+  Data_Get_Struct(hs, SOCKET_DATA, data);
+
+  if (data->socket_desc == -1) {
+    hs_free(data);
+  }
+
+  data->socket_desc = socket(AF_INET , SOCK_STREAM , 0);
+  if (data->socket_desc == -1) {
+      rb_warn("Could not create socket");
+  }
+
+  server.sin_addr.s_addr = inet_addr(data->host);
+  server.sin_family = AF_INET;
+  server.sin_port = htons(data->port);
+
+  if (connect(data->socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0) {
+    rb_raise(rb_eStandardError, "HS: connect error");
+  }
+
+  return Qnil;
+}
+
+// Re-establishes a connection to HS server
+//
+// @param [Handlersocket] hs
+//
+// @return [nil]
+//
+static VALUE rb_hs_reconnect(VALUE hs) {
+  rb_hs_disconnect(hs);
+  rb_hs_connect(hs);
+
+  return Qnil;
+}
+
+// Constructor for a Handlersocket object
+//
+// @param [Handlersocket] hs
+// @param [String] host
+// @param [Fixnum] port
+//
+// @return [nil]
+//
+static VALUE rb_hs_initialize(VALUE hs, VALUE host, VALUE port) {
+  SOCKET_DATA *data;
+  Data_Get_Struct(hs, SOCKET_DATA, data);
+
+  data->host = StringValuePtr(host);
+  data->port = NUM2INT(port);
+  data->socket_desc = -1;
+
+  rb_hs_connect(hs);
+
+  return Qnil;
+}
+
+
+void Init_handlersocket_ext(void) {
+  rb_Handlersocket = rb_const_get(rb_cObject, rb_intern("Handlersocket"));
+
+  rb_define_alloc_func(rb_Handlersocket, hs_alloc);
+  rb_define_method(rb_Handlersocket, "initialize", rb_hs_initialize, 2);
+  rb_define_method(rb_Handlersocket, "connect", rb_hs_connect, 0);
+  rb_define_method(rb_Handlersocket, "disconnect", rb_hs_disconnect, 0);
+  rb_define_method(rb_Handlersocket, "reconnect", rb_hs_reconnect, 0);
+  rb_define_method(rb_Handlersocket, "query", rb_hs_query, 1);
+}

data/ext/handlersocket_ext/socket/send.h

@@ -0,0 +1,135 @@
+#include <arpa/inet.h>
+#include <sys/ioctl.h>
+
+// Writes passed message to a socket
+//
+// @param [int] socket_desc
+// @param [char*] message
+//
+#define SOCKET_WRITE(socket_desc, message) send(socket_desc, message, strlen(message) , 0)
+
+
+// Concatenates a string +s1+ and a string +s2+ with the length +l2+
+// Result will be placed into +s1+
+//
+// @param [char**] s1
+// @param [char*] s2
+// @param [int] l2
+//
+void concat(char **s1, char *s2, int l2) {
+  int l1;
+  char *res;
+
+  l1 = *s1 ? strlen(*s1) : 0;
+  res = realloc(*s1, l1 + l2 + 1);
+
+  if (res) {
+    memcpy(res + l1, s2, l2);
+    res[l1 + l2] = 0;
+    *s1 = res;
+  }
+}
+
+// Writes an array of Ruby strings to passed socket
+//
+// @param [int] socket_desc
+// @param [Array<String>] ary
+//
+static void hs_write(int socket_desc, VALUE ary) {
+  char *message, *buffer;
+  int i, l1, l2;
+  VALUE item;
+  message = NULL;
+
+  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+    item = RARRAY_AREF(ary, i);
+    buffer = StringValuePtr(item);
+    l1 = message ? strlen(message) : 0;
+    l2 = buffer  ? strlen(buffer)  : 0;
+    if (l1 == 0) {
+      message = realloc(message, l2);
+      strcpy(message, buffer);
+    } else {
+      message = realloc(message, l1 + l2 + 2);
+      message[l1] = '\t';
+      memcpy(message + l1 + 1, buffer, l2);
+      message[l1 + l2 + 1] = 0;
+    }
+  }
+  l1 = strlen(message);
+  message = realloc(message, l1 + 2);
+  message[l1] = '\n';
+  message[l1 + 1] = 0;
+
+  SOCKET_WRITE(socket_desc, message);
+}
+
+// Reads all available data from the passed socket until the new line
+//
+// @param [int] socket_desc
+//
+// @return [char*] reply from the server
+//
+// @raise [StandardError] when socket is closed
+//
+static char* hs_read_until_newline(int socket_desc) {
+  int buffer_length = 100, bytes_read = 0;
+  char buf[buffer_length];
+  char *result = NULL;
+  int end_of_line_matched = 0;
+
+  while (!end_of_line_matched) {
+    bytes_read = read(socket_desc, buf, buffer_length);
+    if (!bytes_read) {
+      rb_raise(rb_eStandardError, "HS: closed socket");
+    }
+    concat(&result, buf, bytes_read);
+    if (buf[bytes_read - 1] == '\n') {
+      end_of_line_matched = 1;
+    }
+  }
+
+  return result;
+}
+
+// Parses "\t"-terminated response from the HS server
+//
+// @param [char*] raw_response
+//
+// @return [Array<String>] parsed reply
+//
+static VALUE hs_parse_response(char* raw_response) {
+  VALUE ary;
+  char *token;
+
+  ary = rb_ary_new();
+
+  while ((token = strsep(&raw_response, "\t\n")) != NULL) {
+    if (strlen(token) > 0) {
+      rb_ary_push(ary, rb_str_new2(token));
+    }
+  }
+
+  free(raw_response);
+  free(token);
+
+  return ary;
+}
+
+// Sends a query to the HS server and parses response
+//
+// @param [Handlersocket] hs
+// @param [Array<String>] req request data
+//
+// @return [Array<String>] reply
+//
+static VALUE rb_hs_query(VALUE hs, VALUE req) {
+  SOCKET_DATA *data;
+  char *raw_result;
+
+  Data_Get_Struct(hs, SOCKET_DATA, data);
+
+  hs_write(data->socket_desc, req);
+  raw_result = hs_read_until_newline(data->socket_desc);
+  return hs_parse_response(raw_result);
+}

data/handlersocket.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'handlersocket/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "handlersocket-rb"
+  spec.version       = Handlersocket::VERSION
+  spec.authors       = ["Ilya Bylich"]
+  spec.email         = ["ibylich@gmail.com"]
+
+  spec.summary       = %q{Zero-dependency implementation of HandlerSocket protocol}
+  spec.homepage      = "https://github.com/iliabylich/handlersocket-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec"
+end

data/handlersocket.yml.sample

@@ -0,0 +1,2 @@
+host: 127.0.0.1
+port: 9999

data/lib/handlersocket.rb

@@ -0,0 +1,58 @@
+require "handlersocket/version"
+
+# Class for establising connection to MySQL's HandlerSocket
+#
+# @example
+#   hs = Handlersocket.new('0.0.0.0', 9999)
+#
+class Handlersocket
+  # @param [String] host
+  # @param [Fixnum] port
+  #
+  def initialize(host, port)
+    @host = host
+    @port = port
+  end
+
+  # Sends a query to Handlersocket server and returns a reply
+  #
+  # @param [Array<String>] args
+  #
+  # @return [Array<String>]
+  #
+  def query(*args)
+    # A stub method
+  end
+
+  # Opens an an index for requests
+  #
+  # @param [String] idx_id id of index
+  # @param [String] db_name name of the database
+  # @param [String] tbl_name name of the table
+  # @param [String] idx_name name of the index
+  # @param [Array<String>] columns you want to get
+  #
+  # @return [Array<String>]
+  #
+  def open_index(idx_id, db_name, tbl_name, idx_name, columns)
+    req = ["P", idx_id, db_name, tbl_name, idx_name, columns.join(",")]
+    query(req)
+  end
+
+  # Runs a find statement on HandlerSocket server and returns matched rows
+  #
+  # @param [String] idx_id id of index
+  # @param [String] op operation ('=', '>', '<')
+  # @param [Array<String>] args arguments for comparison
+  # @param [Array<String>] extra arguments like limit and offset
+  #
+  # @return [Array<String>] matched rows
+  #
+  def find(idx_id, op, args, extra = [])
+    req = [idx_id, op, args.length.to_s, *args, *extra]
+    query(req)
+  end
+end
+
+# require 'handlersocket/pure'
+# require 'handlersocket/ext'

data/lib/handlersocket/ext.rb

@@ -0,0 +1,2 @@
+require 'handlersocket'
+require 'handlersocket_ext'

data/lib/handlersocket/pure.rb

@@ -0,0 +1,27 @@
+require 'socket'
+require 'handlersocket'
+
+# Pure Ruby implementation of HS protocol
+#
+# Sockets implementation is very slow in MRI, use HandlerSocket::Ext for better performance
+#
+class Handlersocket
+  # Returns a memoized instance of TCP socket
+  #
+  # @return [TCPSocket]
+  #
+  def socket
+    @socket ||= TCPSocket.new(@host, @port)
+  end
+
+  # Sends request to a HS server and returns a reply
+  #
+  # @param [Array<String>] req
+  #
+  # @return [Array<String>]
+  #
+  def query(req)
+    socket.puts(req.join("\t"))
+    socket.gets.chomp.split("\t")
+  end
+end

data/lib/handlersocket/version.rb

@@ -0,0 +1,3 @@
+class Handlersocket
+  VERSION = "0.1.0"
+end

data/local_handlersocket.yml

@@ -0,0 +1,2 @@
+host: 127.0.0.1
+port: 9997

data/mysql.yml.sample

@@ -0,0 +1,3 @@
+host: localhost
+username: root
+password:

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: handlersocket-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ilya Bylich
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ibylich@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/mock_hs_server
+- bin/setup
+- ext/handlersocket_ext/extconf.rb
+- ext/handlersocket_ext/handlersocket_ext.c
+- ext/handlersocket_ext/socket/send.h
+- handlersocket.gemspec
+- handlersocket.yml.sample
+- lib/handlersocket.rb
+- lib/handlersocket/ext.rb
+- lib/handlersocket/pure.rb
+- lib/handlersocket/version.rb
+- local_handlersocket.yml
+- mysql.yml.sample
+homepage: https://github.com/iliabylich/handlersocket-ruby
+licenses:
+- MIT
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Zero-dependency implementation of HandlerSocket protocol
+test_files: []