rdkit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7f8dab0976c2aaf2d8045793c9c52713a7ff867
+  data.tar.gz: 0cb9f68b9684fc6c2a5e553202a724396ae75d46
+SHA512:
+  metadata.gz: 2e1c7b165b6cc10f382afd74618dd5a5df2a1722e8bbad9a5eb69c2742449fe6f2ca6e39ec0a4b163574b4cce8ae8aaf78a45ccbafddd18e26dc7896e072956d
+  data.tar.gz: 2b6889a5764936fb592b0d29418aab64108c7cb53f1b22c2d2e87381a9259e2f8ab7f3f8f4e0e3366a5e554f1399d6a6218b8a28317ed5ef30f7b83ace5a964f

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+script: bundle exec rspec

data/Gemfile

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

data/README.md

@@ -0,0 +1,209 @@
+# RDKit
+
+RDKit is a simple toolkit to write Redis-like, single-threaded multiplexing-IO server.
+
+The server speaks [Redis RESP protocol](http://redis.io/topics/protocol), so you can reuse many Redis-compatible clients and tools such as:
+
+- `redis-cli`
+- `redis-benchmark`
+- [Redic](https://github.com/amakawa/redic)
+
+And a lot more.
+
+`RDKit` is used to power the [520 Love Radio](http://s.weibo.com/weibo/same%2520%25E7%2594%25B5%25E5%258F%25B0) service of [same.com](http://same.com)
+
+[![Code Climate](https://codeclimate.com/github/forresty/rdkit/badges/gpa.svg)](https://codeclimate.com/github/forresty/rdkit)
+[![Build Status](https://travis-ci.org/forresty/rdkit.svg?branch=master)](https://travis-ci.org/forresty/rdkit)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rdkit'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rdkit
+
+## Usage
+
+see examples under `example` folder.
+
+### Implementing a counter server
+
+A simple counter server source code listing:
+
+```ruby
+require 'rdkit'
+
+# counter/version.rb
+module Counter
+  VERSION = '0.0.1'
+end
+
+# counter/core.rb
+module Counter
+  class Core < RDKit::Core
+    attr_accessor :count
+
+    def initialize
+      @count = 0
+      @last_tick = Time.now
+    end
+
+    # `tick!` is called periodically by RDKit
+    def tick!
+      @last_tick = Time.now
+    end
+
+    def incr(n)
+      @count += n
+    end
+
+    def introspection
+      {
+        counter_version: Counter::VERSION,
+        count: @count,
+        last_tick: @last_tick
+      }
+    end
+  end
+end
+
+# counter/command_runner.rb
+module Counter
+  class CommandRunner < RDKit::RESPRunner
+    def initialize(counter)
+      @counter = counter
+    end
+
+    # every public method of this class will be accessible by clients
+    def count
+      @counter.count
+    end
+
+    def incr(n=1)
+      @counter.incr(n.to_i)
+    end
+  end
+end
+
+# counter/server.rb
+module Counter
+  class Server < RDKit::Server
+    def initialize
+      super('0.0.0.0', 3721)
+
+      # @core is required by RDKit
+      @core = Core.new
+
+      # @runner is also required by RDKit
+      @runner = CommandRunner.new(@core)
+    end
+
+    def introspection
+      super.merge(counter: @core.introspection)
+    end
+  end
+end
+
+# start server
+
+server = Counter::Server.new
+
+trap(:INT) { server.stop }
+
+server.start
+
+```
+
+### Connect using `redis-cli`
+
+```shell
+$ redis-cli -p 3721
+127.0.0.1:3721> count
+(integer) 0
+127.0.0.1:3721> incr
+(integer) 1
+127.0.0.1:3721> incr 10
+(integer) 11
+127.0.0.1:3721> count
+(integer) 11
+127.0.0.1:3721> info
+# Server
+rdkit_version:0.0.1
+multiplexing_api:select
+process_id:15083
+tcp_port:3721
+uptime_in_seconds:268
+uptime_in_days:0
+hz:10
+
+# Clients
+connected_clients:1
+connected_clients_peak:1
+
+# Memory
+used_memory_rss:31.89M
+used_memory_peak:31.89M
+
+# Counter
+counter_version:0.0.1
+count:11
+last_tick:2015-05-27 20:15:38 +0800
+
+# Stats
+total_connections_received:1
+total_commands_processed:6
+
+127.0.0.1:3721> xx
+(error) ERR unknown command 'xx'
+```
+
+### Benchmarking with `redis-benchmark`
+
+```shell
+$ redis-benchmark -p 3721 incr
+====== count ======
+  10000 requests completed in 0.73 seconds
+  50 parallel clients
+  3 bytes payload
+  keep alive: 1
+
+0.01% <= 1 milliseconds
+2.27% <= 2 milliseconds
+42.31% <= 3 milliseconds
+63.99% <= 4 milliseconds
+96.14% <= 5 milliseconds
+...
+99.97% <= 68 milliseconds
+99.98% <= 71 milliseconds
+99.99% <= 74 milliseconds
+100.00% <= 77 milliseconds
+13679.89 requests per second
+```
+
+Since it is single-threaded, the count will be correct:
+
+```shell
+127.0.0.1:3721> count
+(integer) 10000
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+1. Fork it ( https://github.com/forresty/rdkit/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,2 @@
+require "bundler/gem_tasks"
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rdkit"
+
+# 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/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/example/counter.rb

@@ -0,0 +1,12 @@
+require 'rdkit'
+
+require_relative 'counter/version'
+require_relative 'counter/core'
+require_relative 'counter/command_runner'
+require_relative 'counter/server'
+
+server = Counter::Server.new
+
+trap(:INT) { server.stop }
+
+server.start

data/example/counter/command_runner.rb

@@ -0,0 +1,16 @@
+module Counter
+  class CommandRunner < RDKit::RESPRunner
+    def initialize(counter)
+      @counter = counter
+    end
+
+    # every public method of this class will be accessible by clients
+    def count
+      @counter.count
+    end
+
+    def incr(n=1)
+      @counter.incr(n.to_i)
+    end
+  end
+end

data/example/counter/core.rb

@@ -0,0 +1,31 @@
+module Counter
+  class Core < RDKit::Core
+    attr_accessor :count
+
+    def initialize
+      @count = 0
+      @last_tick = Time.now
+    end
+
+    def incr(n)
+      @count += n
+    end
+
+    ###########################################
+    # overriding required RDKit::Core methods
+    ###########################################
+
+    # `tick!` is called periodically by RDKit
+    def tick!
+      @last_tick = Time.now
+    end
+
+    def introspection
+      {
+        counter_version: Counter::VERSION,
+        count: @count,
+        last_tick: @last_tick
+      }
+    end
+  end
+end

data/example/counter/server.rb

@@ -0,0 +1,17 @@
+module Counter
+  class Server < RDKit::Server
+    def initialize
+      super('0.0.0.0', 3721)
+
+      # @core is required by RDKit
+      @core = Core.new
+
+      # @runner is also required by RDKit
+      @runner = CommandRunner.new(@core)
+    end
+
+    def introspection
+      super.merge(counter: @core.introspection)
+    end
+  end
+end

data/example/counter/version.rb

@@ -0,0 +1,3 @@
+module Counter
+  VERSION = '0.0.1'
+end

data/lib/rdkit.rb

@@ -0,0 +1,10 @@
+require_relative 'rdkit/version'
+require_relative 'rdkit/errors'
+require_relative 'rdkit/resp'
+require_relative 'rdkit/logger'
+require_relative 'rdkit/introspection'
+require_relative 'rdkit/inheritable'
+require_relative 'rdkit/core'
+require_relative 'rdkit/command_parser'
+require_relative 'rdkit/resp_runner'
+require_relative 'rdkit/server'

data/lib/rdkit/command_parser.rb

@@ -0,0 +1,45 @@
+require "hiredis/reader"
+# http://redis.io/topics/protocol
+# Hiredis::Reader does not handle inline commands, so
+
+module RDKit
+  class CommandParser
+    def initialize
+      @reader = Hiredis::Reader.new
+      @buffer = []
+      @regexp = Regexp.new("\\A(.+)\\r\\n\\z")
+      @error  = nil
+    end
+
+    def feed(data)
+      if data =~ @regexp
+        @buffer << $1.split
+      else
+        @reader.feed(data)
+
+        read_into_buffer!
+      end
+    end
+
+    def gets
+      raise @error unless @error.nil?
+
+      if result = @buffer.shift
+
+        result
+      else
+        @reader.gets
+      end
+    end
+
+    private
+
+    def read_into_buffer!
+      until (reply = @reader.gets) == false
+        @buffer << reply
+      end
+    rescue RuntimeError => e
+      @error = ProtocolError.new(e) if e.message =~ /Protocol error/
+    end
+  end
+end

data/lib/rdkit/core.rb

@@ -0,0 +1,13 @@
+module RDKit
+  class Core
+    include Inheritable
+
+    def tick!
+      raise ShouldOverrideError
+    end
+
+    def introspection
+      raise ShouldOverrideError
+    end
+  end
+end

data/lib/rdkit/errors.rb

@@ -0,0 +1,12 @@
+module RDKit
+  class RDKitError < StandardError; end
+
+  class ProtocolError < RDKitError; end
+  class UnknownCommandError < ProtocolError; end
+  class WrongNumberOfArgumentError < ProtocolError; end
+
+  class NotImplementedError < RDKitError; end
+
+  class SDKRequirementNotMetError < RDKitError; end
+  class ShouldOverrideError < SDKRequirementNotMetError; end
+end

data/lib/rdkit/inheritable.rb

@@ -0,0 +1,15 @@
+module RDKit
+  module Inheritable
+    def self.included(base)
+      base.instance_eval do
+        def instance(*args)
+          @subclass.new(*args)
+        end
+
+        def inherited(klass)
+          @subclass = klass
+        end
+      end
+    end
+  end
+end

data/lib/rdkit/introspection.rb

@@ -0,0 +1,82 @@
+# 127.0.0.1:6379> info
+# # Server
+# redis_version:2.8.17
+# redis_git_sha1:00000000
+# redis_git_dirty:0
+# redis_build_id:32eb139b4f2b63
+# redis_mode:standalone
+# os:Darwin 13.4.0 x86_64
+# arch_bits:64
+# multiplexing_api:kqueue
+# gcc_version:4.2.1
+# process_id:471
+# run_id:efa5b449cc3ba9c53f7bbb159a773e6ff20d575c
+# tcp_port:6379
+# uptime_in_seconds:1510124
+# uptime_in_days:17
+# hz:10
+#
+# # Clients
+# connected_clients:1
+# client_longest_output_list:0
+# client_biggest_input_buf:0
+#
+# # Memory
+# used_memory:124510288
+# used_memory_human:118.74M
+# used_memory_rss:119885824
+# used_memory_peak:124510288
+# used_memory_peak_human:118.74M
+# used_memory_lua:33792
+# mem_fragmentation_ratio:0.96
+# mem_allocator:libc
+#
+# # Persistence
+#
+# # Stats
+# total_connections_received:74408
+# total_commands_processed:5122851
+# instantaneous_ops_per_sec:0
+# rejected_connections:0
+# pubsub_channels:0
+# pubsub_patterns:0
+
+module RDKit
+  module Introspection
+    class Stats
+      attr_reader :data
+
+      def initialize
+        @data = {}
+
+        @data.default = 0
+      end
+
+      module ClassMethods
+        @@instance = Stats.new
+
+        def incr(key)
+          @@instance.data[key] += 1
+        end
+
+        def info
+          @@instance.data
+        end
+      end
+
+      class << self; include ClassMethods; end
+    end
+
+    module ClassMethods
+      def register(server)
+        @@server = server
+      end
+
+      def info
+        @@server.introspection.merge({ stats: Stats.info })
+      end
+    end
+
+    class << self; include ClassMethods; end
+  end
+end

data/lib/rdkit/logger.rb

@@ -0,0 +1,27 @@
+module RDKit
+  class Logger
+    def debug(message)
+      return unless $DEBUG && ENV['RACK_ENV'] != 'test'
+
+      log(message)
+    end
+
+    def info(message)
+      log(message)
+    end
+
+    def warn(message)
+      log(message)
+    end
+
+    def log(message)
+      case message
+      when StandardError
+        puts message.inspect
+        puts message.backtrace.join("\n")
+      else
+        puts message
+      end
+    end
+  end
+end

data/lib/rdkit/resp.rb

@@ -0,0 +1,26 @@
+# http://redis.io/topics/protocol
+
+module RDKit
+  class RESP
+    module ClassMethods
+      def compose(data)
+        case data
+        when Integer
+          ":#{data}\r\n"
+        when Array
+          "*#{data.size}\r\n" + data.map { |i| compose(i) }.join
+        when NilClass
+          # Null Bulk String, not Null Array of "*-1\r\n"
+          "$-1\r\n"
+        when StandardError
+          "-#{data.message}\r\n"
+        else
+          # always Bulk String
+          "$#{data.bytesize}\r\n#{data}\r\n"
+        end
+      end
+    end
+
+    class << self; include ClassMethods; end
+  end
+end

data/lib/rdkit/resp_runner.rb

@@ -0,0 +1,46 @@
+module RDKit
+  class RESPRunner
+    include Inheritable
+
+    def resp(cmd)
+      RESP.compose(call(cmd))
+    rescue => e
+      RESP.compose(e)
+    end
+
+    # 获取服务器状态
+    def info
+      Introspection.info.map do |type, value|
+        "# #{type.capitalize}\r\n" + value.map { |k, v| "#{k}:#{v}" }.join("\r\n") + "\r\n"
+      end.join("\r\n") + "\r\n"
+    end
+
+    private
+
+    def call(cmd)
+      @logger ||= Logger.new
+
+      Introspection::Stats.incr(:total_commands_processed)
+
+      @logger.debug "running command: #{cmd}"
+      cmd, *args = cmd
+
+      cmd.downcase!
+
+      if self.respond_to?(cmd)
+        self.__send__(cmd, *args)
+      else
+        raise UnknownCommandError, "ERR unknown command '#{cmd}'"
+      end
+    rescue ArgumentError => e
+      raise WrongNumberOfArgumentError, "ERR wrong number of arguments for '#{cmd}' command"
+    end
+
+    module RedisCompatibility
+      def select(id); 'OK'; end
+      def ping; 'PONG'; end
+    end
+
+    include RedisCompatibility
+  end
+end

data/lib/rdkit/server.rb

@@ -0,0 +1,192 @@
+require 'newrelic_rpm'
+
+module RDKit
+  class Server
+    HZ = 10
+    CYCLES_TIL_MEMORY_RESAMPLE = 1000
+
+    attr_reader :server_up_since
+    attr_reader :runner
+    attr_reader :core
+    attr_reader :host, :port
+
+    def initialize(host, port)
+      @host, @port = host, port
+
+      @cycles = 0
+      @peak_memory = 0
+      @peak_connected_clients = 0
+
+      @clients, @command_parsers = Hash.new, Hash.new
+
+      @logger = Logger.new
+
+      Introspection.register(self)
+
+      @server_up_since = Time.now
+    end
+
+    def sanity_check!
+      unless @host && @port
+        raise SDKRequirementNotMetError, '@host and @port are required for server to run'
+      end
+
+      if @core.nil?
+        raise SDKRequirementNotMetError, '@core is required to represent your business logics'
+      end
+
+      if @runner.nil?
+        raise SDKRequirementNotMetError, '@runner is required to act as an RESP frontend'
+      end
+    end
+
+    def start
+      sanity_check!
+
+      @server_socket = TCPServer.new(@host, @port)
+
+      run_acceptor
+    end
+
+    def stop
+      @logger.warn "signal caught, shutting down..."
+      exit
+    end
+
+    def introspection
+      {
+        server: {
+          rdkit_version: RDKit::VERSION,
+          multiplexing_api: 'select',
+          process_id: Process.pid,
+          tcp_port: @port,
+          uptime_in_seconds: (Time.now - @server_up_since).to_i,
+          uptime_in_days: ((Time.now - @server_up_since) / (24 * 60 * 60)).to_i,
+          hz: HZ,
+        },
+        clients: {
+          connected_clients: @clients.size,
+          connected_clients_peak: @peak_connected_clients
+        },
+        memory: {
+          used_memory_rss: used_memory_rss_in_mb,
+          used_memory_peak: used_memory_peak_in_mb
+        },
+      }
+    end
+
+    private
+
+    def used_memory_rss_in_mb
+      update_peak_memory!
+
+      '%0.2f' % used_memory_rss + 'M'
+    end
+
+    def used_memory_peak_in_mb
+      '%0.2f' % @peak_memory + 'M'
+    end
+
+    def add_client
+      Introspection::Stats.incr(:total_connections_received)
+
+      socket = @server_socket.accept_nonblock
+
+      @command_parsers[socket] = CommandParser.new
+
+      @clients[socket] = Fiber.new do
+         with_error_handling(socket) do |io|
+           loop { process(io); Fiber.yield }
+         end
+      end
+
+      @logger.debug "client #{socket} connected"
+
+      return @clients[socket]
+    end
+
+    def process(io)
+      feed_parser(io)
+
+      until (reply = get_parser_reply(io)) == false
+        send_response(io, reply)
+      end
+    end
+
+    def feed_parser(io)
+      cmd = io.readpartial(1024)
+
+      @command_parsers[io].feed(cmd)
+    end
+
+    def get_parser_reply(io)
+      @command_parsers[io].gets
+    end
+
+    def send_response(io, cmd)
+      resp = runner.resp(cmd)
+
+      @logger.debug(resp)
+
+      io.write(resp)
+    end
+
+    def with_error_handling(socket, &block)
+
+      block.call(socket)
+
+    rescue Errno::ECONNRESET, EOFError => e
+      # client disconnected
+      @logger.debug "client #{socket.inspect} has disconnected"
+      @logger.debug e
+      @command_parsers.delete(socket)
+      @clients.delete(socket)
+    rescue ProtocolError => e
+      # client protocol error, force disconnect
+      @logger.debug "client protocol error"
+      @logger.debug e
+      socket.close
+      @command_parsers.delete(socket)
+      @clients.delete(socket)
+    end
+
+    def run_acceptor
+      @logger.info "accepting on shared socket (#{@host}:#{@port})"
+
+      loop do
+        readable, _ = IO.select([@server_socket, @clients.keys].flatten, nil, nil, 1.0 / HZ)
+
+        if readable
+          readable.each do |socket|
+            if socket == @server_socket
+              add_client
+            else
+              # client is a Fiber
+              client = @clients[socket]
+              client.resume
+            end
+          end
+        end
+
+        update_peak_memory! if @cycles % CYCLES_TIL_MEMORY_RESAMPLE == 0
+        update_peak_connected_clients!
+
+        @cycles += 1
+
+        core.tick!
+      end
+    end
+
+    def update_peak_memory!
+      @peak_memory = [@peak_memory, used_memory_rss].max
+    end
+
+    def update_peak_connected_clients!
+      @peak_connected_clients = [@peak_connected_clients, @clients.size].max
+    end
+
+    def used_memory_rss
+      NewRelic::Agent::Samplers::MemorySampler.new.sampler.get_sample
+    end
+  end
+end

data/lib/rdkit/version.rb

@@ -0,0 +1,3 @@
+module RDKit
+  VERSION = '0.0.1'
+end

data/rdkit.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rdkit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rdkit"
+  spec.version       = RDKit::VERSION
+  spec.authors       = ["Forrest Ye"]
+  spec.email         = ["afu@forresty.com"]
+
+  spec.summary       = %q{RDKit is a simple toolkit to write Redis-like, single-threaded multiplexing-IO server.}
+  spec.homepage      = "http://github.com/forresty/rdkit"
+
+  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_runtime_dependency 'hiredis'
+  spec.add_runtime_dependency 'newrelic_rpm'
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: rdkit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Forrest Ye
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: newrelic_rpm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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: 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:
+- afu@forresty.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- example/counter.rb
+- example/counter/command_runner.rb
+- example/counter/core.rb
+- example/counter/server.rb
+- example/counter/version.rb
+- lib/rdkit.rb
+- lib/rdkit/command_parser.rb
+- lib/rdkit/core.rb
+- lib/rdkit/errors.rb
+- lib/rdkit/inheritable.rb
+- lib/rdkit/introspection.rb
+- lib/rdkit/logger.rb
+- lib/rdkit/resp.rb
+- lib/rdkit/resp_runner.rb
+- lib/rdkit/server.rb
+- lib/rdkit/version.rb
+- rdkit.gemspec
+homepage: http://github.com/forresty/rdkit
+licenses: []
+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.5
+signing_key: 
+specification_version: 4
+summary: RDKit is a simple toolkit to write Redis-like, single-threaded multiplexing-IO
+  server.
+test_files: []