rdkit 0.0.1 → 0.1.4

data/example/blocking/command_runner.rb

@@ -0,0 +1,28 @@
+module Blocking
+  class CommandRunner < RDKit::RESPRunner
+    attr_reader :core
+
+    def initialize(core)
+      @core = core
+    end
+
+    def block_with_callback
+      core.block_with_callback
+
+      # this is ignored, instead `on_success` block of `core.block_with_callback` is evaluated and returned
+      'OK'
+    end
+
+    def block
+      core.block
+
+      'OK'
+    end
+
+    def nonblock
+      core.nonblock
+
+      'OK'
+    end
+  end
+end

data/example/blocking/core.rb

@@ -0,0 +1,24 @@
+module Blocking
+  class Core < RDKit::Core
+    def block_with_callback
+      on_success = lambda { 'success' }
+
+      server.blocking(on_success) { do_something }
+    end
+
+    def block
+      server.blocking { do_something }
+    end
+
+    def nonblock
+      do_something
+    end
+
+    def do_something
+      sleep 1
+    end
+
+    def tick!
+    end
+  end
+end

data/example/blocking/server.rb

@@ -0,0 +1,10 @@
+module Blocking
+  class Server < RDKit::Server
+    def initialize
+      super('0.0.0.0', 3721)
+
+      @core = Core.new
+      @runner = CommandRunner.new(core)
+    end
+  end
+end

data/example/blocking/version.rb

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

data/example/callbacks.rb

@@ -0,0 +1,9 @@
+require 'rdkit'
+
+require_relative 'callbacks/core'
+require_relative 'callbacks/command_runner'
+require_relative 'callbacks/server'
+
+server = Callbacks::Server.new
+
+server.start

data/example/callbacks/command_runner.rb

@@ -0,0 +1,21 @@
+module Callbacks
+  class CommandRunner < RDKit::RESPRunner
+    attr_reader :core
+
+    def initialize(core)
+      @core = core
+    end
+
+    def block
+      core.block
+
+      'OK'
+    end
+
+    def nonblock
+      core.nonblock
+
+      'OK'
+    end
+  end
+end

data/example/callbacks/core.rb

@@ -0,0 +1,18 @@
+module Callbacks
+  class Core < RDKit::Core
+    def block
+      server.blocking { do_something }
+    end
+
+    def nonblock
+      do_something
+    end
+
+    def do_something
+      sleep(rand)
+    end
+
+    def tick!
+    end
+  end
+end

data/example/callbacks/server.rb

@@ -0,0 +1,30 @@
+module Callbacks
+  class Server < RDKit::Server
+    def initialize
+      super('0.0.0.0', 3721)
+
+      @core = Core.new
+      @runner = CommandRunner.new(core)
+    end
+
+    def client_connected(client)
+      puts "client_connected: #{client.id}"
+    end
+
+    def client_disconnected(client)
+      puts "client_disconnected: #{client.id}"
+    end
+
+    def client_command_processed(client)
+      puts "client_command_processed: #{client.id}"
+    end
+
+    def client_block_resumed(client)
+      puts "client_block_resumed: #{client.id}"
+    end
+
+    def client_blocked(client)
+      puts "client_blocked: #{client.id}"
+    end
+  end
+end

data/example/counter.rb

@@ -7,6 +7,4 @@ require_relative 'counter/server'
 
 server = Counter::Server.new
 
-trap(:INT) { server.stop }
-
 server.start

data/example/counter/command_runner.rb

@@ -12,5 +12,9 @@ module Counter
     def incr(n=1)
       @counter.incr(n.to_i)
     end
+
+    def add(*elements)
+      @counter.add(elements.map(&:to_i))
+    end
   end
 end

data/example/counter/core.rb

@@ -11,6 +11,10 @@ module Counter
       @count += n
     end
 
+    def add(elements)
+      @count += elements.inject(&:+)
+    end
+
     ###########################################
     # overriding required RDKit::Core methods
     ###########################################

data/example/http.rb

@@ -0,0 +1,9 @@
+require 'rdkit'
+
+require_relative 'http/core'
+require_relative 'http/responder'
+require_relative 'http/server'
+
+server = HTTP::Server.new
+
+server.start

data/example/http/core.rb

@@ -0,0 +1,18 @@
+module HTTP
+  class Core < RDKit::Core
+    def initialize
+      @last_tick = Time.now
+    end
+
+    # `tick!` is called periodically by RDKit
+    def tick!
+      @last_tick = Time.now
+    end
+
+    def introspection
+      {
+        last_tick: @last_tick
+      }
+    end
+  end
+end

data/example/http/responder.rb

@@ -0,0 +1,7 @@
+module HTTP
+  class Responder < RDKit::HTTPResponder
+    get '/hello' do
+      [200, {}, ['OK']]
+    end
+  end
+end

data/example/http/server.rb

@@ -0,0 +1,19 @@
+module HTTP
+  class Server < RDKit::Server
+    def initialize
+      super('0.0.0.0', 3721)
+
+      # @core is required by RDKit
+      @core = Core.new
+
+      # @responder is also required by RDKit
+      @responder = Responder.new
+
+      @parser_class = RDKit::HTTPParser
+    end
+
+    def introspection
+      super.merge(counter: @core.introspection)
+    end
+  end
+end

data/lib/rdkit.rb

@@ -1,10 +1,27 @@
 require_relative 'rdkit/version'
+require_relative 'rdkit/core_ext'
 require_relative 'rdkit/errors'
+require_relative 'rdkit/configuration'
+require_relative 'rdkit/notification_center'
+require_relative 'rdkit/slow_log'
 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/resp_parser'
+require_relative 'rdkit/http_parser'
+
+require_relative 'rdkit/simple_commands'
+require_relative 'rdkit/rd_object'
+require_relative 'rdkit/db_commands'
+require_relative 'rdkit/subcommands'
+
+require_relative 'rdkit/resp_responder'
+require_relative 'rdkit/http_responder'
+
+require_relative 'rdkit/client'
+require_relative 'rdkit/memory_monitoring'
+require_relative 'rdkit/db'
+require_relative 'rdkit/callbacks'
 require_relative 'rdkit/server'

data/lib/rdkit/callbacks.rb

@@ -0,0 +1,10 @@
+module RDKit
+  module Callbacks
+    def server_started; end
+    def client_connected(client); end
+    def client_disconnected(client); end
+    def client_command_processed(client); end
+    def client_block_resumed(client); end
+    def client_blocked(client); end
+  end
+end

data/lib/rdkit/client.rb

@@ -0,0 +1,157 @@
+require 'thread/future'
+
+module RDKit
+  class Client
+    attr_accessor :id
+    attr_accessor :name
+    attr_accessor :fd
+    attr_accessor :last_command
+    attr_reader   :socket
+
+    def initialize(socket, server)
+      @server = server
+      @socket = socket
+      @responder = server.responder
+      @command_parser = server.parser_class.new
+      @logger = server.logger
+      @created_at = Time.now
+      @last_interacted_at = Time.now
+
+      @fiber = Fiber.new do
+        with_error_handling(socket) do |io|
+          loop { process; Fiber.yield }
+        end
+      end
+    end
+
+    def resume
+      @last_interacted_at = Time.now
+
+      @fiber.resume
+    end
+
+    def blocking(on_success=nil, &block)
+      @blocked_at = Time.now
+
+      @on_block_success = on_success
+
+      @future = Thread.future(@server.pool) { block.call }
+    end
+
+    def finished?
+      @future.delivered?
+    end
+
+    def unblock!
+      Introspection::Commandstats.record("bg_#{last_command}", ((Time.now - @blocked_at) * 1_000_000).to_i)
+
+      @blocked_at = nil
+
+      @server.client_block_resumed(self)
+      @fiber.resume
+    end
+
+    def info
+      {
+        id:   @id,
+        addr: socket_addr,
+        fd:   @socket.fileno,
+        name: @name,
+        age:  age,
+        idle: idle,
+        cmd:  @last_command
+      }
+    end
+
+    def socket_addr
+      @socket.remote_address.inspect_sockaddr
+    end
+
+    def name=(name)
+      # http://www.asciitable.com
+      # `networking.c` in redis source code
+      name.each_char { |c| raise IllegalClientNameError unless c >= '!' && c <= '~' }
+
+      @name = name
+    end
+
+    def kill!
+      @socket.close
+      @server.delete(@socket)
+    end
+
+    private
+
+    def age
+      (Time.now - @created_at).to_i
+    end
+
+    def idle
+      (Time.now - @last_interacted_at).to_i
+    end
+
+    def with_error_handling(socket, &block)
+
+      block.call(socket)
+
+    rescue IOError, Errno::ECONNRESET, EOFError => e
+      # client disconnected
+      @logger.debug "client #{socket.inspect} has disconnected"
+      @logger.debug e
+
+      raise ClientDisconnectedError
+    rescue ProtocolError => e
+      # client protocol error, force disconnect
+      @logger.debug "client protocol error"
+      @logger.debug e
+
+      raise ClientDisconnectedError
+    end
+
+    def process
+      feed_parser
+
+      until (reply = get_parser_reply) == false
+        execute_and_send_response(reply)
+      end
+    end
+
+    def feed_parser
+      cmd = @socket.readpartial(1024)
+
+      Introspection::Stats.incr(:total_net_input_bytes, cmd.bytesize)
+
+      @command_parser.feed(cmd)
+    end
+
+    def get_parser_reply
+      @command_parser.gets
+    end
+
+    def execute_and_send_response(cmd)
+      @last_command = cmd.first
+
+      @server.monitors.each do |client|
+        msg = "+#{Time.now.to_f} [#{socket_addr}] #{ cmd.map { |c| %Q{"#{c}"}}.join(' ') }\r\n"
+
+        client.socket.write(msg)
+      end
+
+      resp, usec = SlowLog.monitor(cmd) { @responder.run(cmd) }
+
+      if @blocked_at
+        @server.client_blocked(self)
+        Fiber.yield
+
+        resp = @responder.run(@on_block_success) if @on_block_success
+      end
+
+      Introspection::Commandstats.record(cmd.first, usec)
+      Introspection::Stats.incr(:total_net_output_bytes, resp.bytesize)
+
+      @logger.debug(resp)
+
+      @socket.write(resp)
+    end
+  end
+end