RDKit

gem 'rdkit'

class YourServer < RDKit::Server
  def initialize
    super('0.0.0.0', 3721)

    @core = YourCore.new
    @responder = YourResponder.new(core)
  end
end

server = YourServer.new

trap(:INT) { server.stop }

server.start

def add(a, b)
  a.to_i + b.to_i
end

def compose(data)
  case data
  when *%w{ OK string list set hash zset none }
    "+#{data}\r\n"
  when true
    ":1\r\n"
  when false
    ":0\r\n"
  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 WrongTypeError
    "-WRONGTYPE #{data.message}\r\n"
  when StandardError
    "-ERR #{data.message}\r\n"
  else
    # always Bulk String
    "$#{data.bytesize}\r\n#{data}\r\n"
  end
end

def tick!
  save_non_critical_data! if server.cycles % 1000 == 0
end

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

# blocking/command_runner.rb

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

# blocking/core.rb

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