ia-redis-rpc 2.0.0.pre.dev

data/redis-rpc.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/redis-rpc/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'ia-redis-rpc'
+  s.version = RedisRpc::VERSION
+  s.license = 'GPL-3.0'
+  s.authors = ['Phuong Nguyen', 'Nathan Farrington']
+  s.email = ['nathan@nathanfarrington.com']
+
+  s.homepage = 'http://github.com/phuongnd08/redis-rpc-ruby'
+  s.summary = 'Lightweight RPC for Redis'
+  s.description = <<-DESCRIPTION
+    RedisRpc is the easiest to use RPC library in the world. (No small claim!).
+    This version is a repackage that only has Ruby implementation.
+
+    Redis is a powerful in-memory data structure server that is useful for building
+    fast distributed systems. Redis implements message queue functionality with its
+    use of list data structures and the `LPOP`, `BLPOP`, and `RPUSH` commands.
+    RedisRpc implements a lightweight RPC mechanism using Redis message queues to
+    temporarily hold RPC request and response messages. These messages are encoded
+    as JSON strings for portability.
+
+    Many other RPC mechanisms are either programming language specific (e.g.
+    Java RMI) or require boiler-plate code for explicit typing (e.g. Thrift).
+    RedisRpc was designed to be extremely easy to use by eliminating boiler-plate
+    code while also being programming language neutral.  High performance was not
+    an initial goal of RedisRpc and other RPC libraries are likely to have better
+    performance. Instead, RedisRpc has better programmer performance; it lets you
+    get something working immediately.
+  DESCRIPTION
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'redis'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'byebug'
+end

data/spec/calculator_spec.rb

@@ -0,0 +1,62 @@
+require_relative 'spec_helper'
+require_relative '../examples/calc.rb'
+
+describe Calculator do
+  context "locally" do
+    let(:calculator) { Calculator.new }
+
+    it 'should calculate' do
+      expect(calculator.val).to be == 0.0
+      expect(calculator.add(3)).to be == 3.0
+      expect(calculator.sub(2)).to be == 1.0
+      expect(calculator.mul(14)).to be == 14.0
+      expect(calculator.div(7)).to be == 2.0
+      expect(calculator.val).to be == 2.0
+      expect(calculator.clr).to be == 0.0
+      expect(calculator.val).to be == 0.0
+    end
+
+    it 'should raise when missing method is called' do
+      # noinspection RubyResolve
+      expect { calculator.a_missing_method }.to raise_error(NoMethodError)
+    end
+  end
+
+  context "over rpc" do
+    let(:rpc_server_builder) { lambda { RedisRpc::Server.new(Redis.new($REDIS_CONFIG), 'calc', Calculator.new, logger: Logger.new(STDERR)) } }
+    before(:each) do
+      @rpc_server = Thread.start {
+        rpc_server_builder.call.run
+      }
+    end
+    after(:each) { rpc_server_builder.call.stop! && @rpc_server.kill; rpc_server_builder.call.flush_queue! }
+    let(:calculator) { RedisRpc::Client.new($REDIS, 'calc', timeout: 2) }
+
+    it 'should calculate' do
+      expect(calculator.val).to be == 0.0
+      expect(calculator.add(3)).to be == 3.0
+      expect(calculator.sub(2)).to be == 1.0
+      expect(calculator.mul(14)).to be == 14.0
+      expect(calculator.div(7)).to be == 2.0
+      expect(calculator.val).to be == 2.0
+      expect(calculator.clr).to be == 0.0
+      expect(calculator.val).to be == 0.0
+    end
+
+    it 'should raise when missing method is called' do
+      # noinspection RubyResolve
+      expect { calculator.a_missing_method }.to raise_error(RedisRpc::RemoteException)
+    end
+
+    it 'should raise timeout when execution expires' do
+      expect { calculator.send(:sleep, 3) }.to raise_error RedisRpc::TimeoutException
+    end
+
+    context "the request is executed late" do
+      it "won't be executed" do
+        allow(calculator).to receive(:get_timeout_at).and_return(Time.now.to_i - 1)
+        expect { calculator.val }.to raise_error(RedisRpc::RemoteException, /Expired RPC call/)
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,26 @@
+require_relative 'spec_helper.rb'
+
+describe RedisRpc::Client do
+  let(:client) { RedisRpc::Client.new($REDIS, 'example', timeout: 1) }
+
+  context "terminated" do
+    it "clear the backlog" do
+      allow($REDIS).to receive(:blpop).and_raise SignalException.new("SIGTERM")
+      expect {
+        client.perform
+      }.to raise_error SignalException
+
+      expect($REDIS.llen("example")).to eq 0
+    end
+  end
+
+  context "timeout" do
+    it "clear the backlog" do
+      expect {
+        client.perform
+      }.to raise_error RedisRpc::TimeoutException
+
+      expect($REDIS.llen("example")).to eq 0
+    end
+  end
+end

data/spec/kwargs_spec.rb

@@ -0,0 +1,32 @@
+require_relative 'spec_helper'
+
+class KwargsEcho
+  def echo(args1, kwarg1:, kwarg2: :kwarg2)
+    {args1: args1, kwarg1: kwarg1, kwarg2: kwarg2}
+  end
+end
+
+describe KwargsEcho do
+  context "locally" do
+    let(:hall) { KwargsEcho.new }
+
+    it 'should echo' do
+      expect(hall.echo(1, kwarg1: :kw1)).to be == {args1: 1, kwarg1: :kw1, kwarg2: :kwarg2}
+    end
+  end
+
+  context "over rpc" do
+    let(:rpc_server_builder) { lambda { RedisRpc::Server.new(Redis.new($REDIS_CONFIG), 'hall', KwargsEcho.new, logger: Logger.new(STDERR)) } }
+    before(:each) do
+      @rpc_server = Thread.start {
+        rpc_server_builder.call.run
+      }
+    end
+    after(:each) { rpc_server_builder.call.stop! && @rpc_server.kill; rpc_server_builder.call.flush_queue! }
+    let(:hall) { RedisRpc::Client.new($REDIS, 'hall', timeout: 2) }
+
+    it 'should echo' do
+      expect(hall.echo(1, kwarg1: :kw1)).to be == { "args1" => 1, "kwarg1" => "kw1", "kwarg2" => "kwarg2" }
+    end
+  end
+end

data/spec/redis-test.conf

@@ -0,0 +1,3 @@
+port 9736
+daemonize yes
+pidfile redis-test.pid

data/spec/server_spec.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+
+describe RedisRpc::Server do
+  context "running" do
+    it "stops" do
+      server = RedisRpc::Server.new(Redis.new($REDIS_CONFIG), 'calc', Array.new, logger: Logger.new(STDERR))
+      server_thread = Thread.start {
+        server.run
+      }
+      expect(server_thread.stop?).to be false
+      expect(server_thread.alive?).to be true
+
+      expect(server.stop!).to be true
+
+      expect(server_thread.stop?).to be true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'bundler'
+require 'logger'
+
+begin
+  Bundler.require(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+RSpec.configure do |config|
+  config.before :suite do
+    raise 'redis-server must be on your path to run this test' if `which redis-server`.empty?
+    $REDIS_CONF_PATH = File.expand_path('../redis-test.conf', __FILE__)
+
+    redis_conf_contents = File.read($REDIS_CONF_PATH)
+    raise "pidfile must be specified in #{$REDIS_CONF_PATH}" unless redis_conf_contents['pidfile']
+
+    $REDIS_CONFIG = {
+      :host => 'localhost',
+      :port => (redis_conf_contents.match(/port ([0-9]+)/)[1].to_i rescue 6379),
+      :db => 15 # we'll be flushing regularly; db 15 is traditionally reserved for test
+    }
+
+    $stdout.write "Starting Redis on port #{$REDIS_CONFIG[:port]}... "; $stdout.flush
+    `redis-server #{$REDIS_CONF_PATH}`
+    puts 'Done.'
+
+    $REDIS = Redis.new($REDIS_CONFIG)
+    begin
+      $REDIS.ping
+    rescue Timeout::Error, Errno::ECONNREFUSED
+      retries ||= 3
+      sleep 1 and retry unless (retries -= 1).zero?
+      $stderr.puts 'Could not connect to Redis after 3 tries.'
+      exit
+    end
+  end
+
+  config.around :each do |example|
+    $REDIS.flushdb
+    example.call
+  end
+
+  config.after :suite do
+    pidfile = (File.read($REDIS_CONF_PATH).match(/pidfile (.+)$/)[1].chomp rescue nil)
+    $stdout.write "\nKilling test redis server... "; $stdout.flush
+    Process.kill("KILL", File.read(pidfile).chomp.to_i)
+    File.unlink(pidfile)
+    puts 'Done.'
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: ia-redis-rpc
+version: !ruby/object:Gem::Version
+  version: 2.0.0.pre.dev
+platform: ruby
+authors:
+- Phuong Nguyen
+- Nathan Farrington
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: |2
+      RedisRpc is the easiest to use RPC library in the world. (No small claim!).
+      This version is a repackage that only has Ruby implementation.
+
+      Redis is a powerful in-memory data structure server that is useful for building
+      fast distributed systems. Redis implements message queue functionality with its
+      use of list data structures and the `LPOP`, `BLPOP`, and `RPUSH` commands.
+      RedisRpc implements a lightweight RPC mechanism using Redis message queues to
+      temporarily hold RPC request and response messages. These messages are encoded
+      as JSON strings for portability.
+
+      Many other RPC mechanisms are either programming language specific (e.g.
+      Java RMI) or require boiler-plate code for explicit typing (e.g. Thrift).
+      RedisRpc was designed to be extremely easy to use by eliminating boiler-plate
+      code while also being programming language neutral.  High performance was not
+      an initial goal of RedisRpc and other RPC libraries are likely to have better
+      performance. Instead, RedisRpc has better programmer performance; it lets you
+      get something working immediately.
+email:
+- nathan@nathanfarrington.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.markdown
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- build-and-publish.sh
+- docs/github-flavored-markdown.rb
+- docs/redisrpc_example.ai
+- docs/redisrpc_example.png
+- docs/redisrpc_example.svg
+- examples/calc.rb
+- examples/client.rb
+- examples/server.rb
+- lib/redis-rpc.rb
+- lib/redis-rpc/version.rb
+- redis-rpc.gemspec
+- spec/calculator_spec.rb
+- spec/client_spec.rb
+- spec/kwargs_spec.rb
+- spec/redis-test.conf
+- spec/server_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/phuongnd08/redis-rpc-ruby
+licenses:
+- GPL-3.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: 1.3.1
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Lightweight RPC for Redis
+test_files:
+- spec/calculator_spec.rb
+- spec/client_spec.rb
+- spec/kwargs_spec.rb
+- spec/redis-test.conf
+- spec/server_spec.rb
+- spec/spec_helper.rb