rcom 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4a59231e2507f9f5010d142bfeb28efeba2e8e6
-  data.tar.gz: a141a111f2e29d337ddcad3a60626885e88430bb
+  metadata.gz: 961e69a1d381ea475b48b4e32d832cd2681d3f26
+  data.tar.gz: e2b0f139d952fd0cb9f18058f58362fa4c89f925
 SHA512:
-  metadata.gz: b7c512e707d70fb3520bcfab86146053b14949d9d28fb3ed3a73268d1ed5df04c337f7a4766d38d5d4b7480d7e68535ac31870868fd5bc42dff2548fc5288d28
-  data.tar.gz: cf8fe056685e4024d07f5e0829c9f5c911303e75ce5b1f7254796c3a755660041fd4971a60ea353e6c3a7c5b865a0e566d15e0fedeb70831133c091323927ed3
+  metadata.gz: adbc997033ab5010d3ce09a0fadc1d47b0675e51a5fdde33df92b67a4a6d15a0452a2bff34e0c06cfd928373d1ec9e879bb5fd40bd3072bbd2a92b969fa6ef0c
+  data.tar.gz: 6c3768301c0079b53bf41fae0495f81222d38c9fcef354933b3ef2121082b43c8a6ef1cd972b6f0272466b33f579817655e42b9f215b6cbee1d2da853e997668

data/README.md

@@ -18,7 +18,7 @@ gem 'rcom'
 
 ## Usage.
 
-Rcom supports the request-response, publish-subscribe and task queues patterns for inter-service messaging. Publishers are non-blocking, subscribers/consumers are blocking and should be run as independent processes. Processes communicate using MessagePack internally.
+Rcom supports the request-response, publish-subscribe and task queue patterns for inter-service messaging. Publishers are non-blocking, subscribers/consumers are blocking and should be run as independent processes. Processes communicate using MessagePack internally.
 
 ### Node.
 
@@ -35,7 +35,7 @@ node = Rcom::Node.new('local').connect
 
 ### Topics.
 
-One service might need to update many different services about an event, following the publish-subscribe pattern. You can publish and subscribe to topics on a node, specifying a key.
+One service might need to update many different services about an event, following the publish-subscribe pattern. You can publish and subscribe to topics on a node, specifying a channel.
 
 - Publisher.
 
@@ -46,7 +46,7 @@ message = {
 }
 
 node = Rcom::Node.new('local').connect
-topic = Rcom::Topic.new(node: node, key: 'users')
+topic = Rcom::Topic.new(node: node, channel: 'users')
 
 topic.publish(message)
 ```
@@ -55,7 +55,7 @@ topic.publish(message)
 
 ```ruby
 node = Rcom::Node.new('local').connect
-topic = Rcom::Topic.new(node: node, key: 'users')
+topic = Rcom::Topic.new(node: node, channel: 'users')
 
 topic.subscribe do |message|
   p message
@@ -64,7 +64,7 @@ end
 
 ## Tasks.
 
-A service might need to push expensive tasks into a queue and forget about them. Tasks will be processed by consumers listening to the queue.
+A service might need to push consuming tasks into a queue and forget about them. Tasks will be processed by consumers listening to the queue.
 
 - Publisher.
 
@@ -75,7 +75,7 @@ message = {
 }
 
 node = Rcom::Node.new('local').connect
-messages = Rcom::Task.new(node: node, queue: 'messages')
+messages = Rcom::Task.new(node: node, channel: 'messages')
 
 messages.publish(message)
 ```
@@ -84,7 +84,7 @@ messages.publish(message)
 
 ```ruby
 node = Rcom::Node.new('local').connect
-messages = Rcom::Task.new(node: node, queue: 'messages')
+messages = Rcom::Task.new(node: node, channel: 'messages')
 
 messages.subscribe do |message|
   sleep 1
@@ -94,37 +94,37 @@ end
 
 ## RPC, requests and responses.
 
-In some cases services need real time informations from other services that can't be asynchronously processed. A service can create a request on a route. The other service listening on the same route will reply to the request.
+In some cases services need real time informations from other services that can't be asynchronously processed. A service can request informations on a channel. The other service listening on the same route will reply to the request.
 
-- Publisher.
+- Request.
 
 ```ruby
-message = {
-  route: 'user.key',
-  args: 1
-}
-
 node = Rcom::Node.new('local').connect
-auth = Rcom::Rpc.new(node: node, service: 'auth')
+service = Rcom::Request.new(node: node, channel: 'auth')
 
-auth.request(message)
+service.get_key(user: 1)
 ```
 
-- Consumer.
+- Response.
 
 ```ruby
 node = Rcom::Node.new('local').connect
-auth = Rcom::Rpc.new(node: node, service: 'auth')
 
-auth.subscribe do |request|
-  request.on('user.key') do |params|
-    request.reply = 'xxxccc'
-  end
-
-  request.on('user.password') do |params|
-    request.reply = 'not authorized'
+class Server
+  def get_key(params)
+    user = params[:user]
+    return nil unless user == 1
+    return 'xxxccc'
   end
 end
+
+service = Rcom::Response.new(
+  node: node,
+  channel: 'auth',
+  server: Server.new
+)
+
+service.serve
 ```
 
 ## Test.

data/lib/rcom/node.rb

@@ -1,18 +1,12 @@
 module Rcom
-  # A node represents a Redis server and has an uri.
   class Node
-    # @return [String]
     attr_reader :uri
 
-    # @param uri [String] Example: 'local'
-    # @raise [ArgumentError] uri is not in .env.
     def initialize(uri)
       raise ArgumentError unless ENV[uri.upcase]
       @uri = ENV[uri.upcase]
     end
 
-    # Connects to Redis.
-    # @return [Redis]
     def connect
       Redis.new(url: uri)
     end

data/lib/rcom/rpc.rb

@@ -1,79 +1,68 @@
 module Rcom
-  # Rpc implements the request/response pattern.
-  class Rpc
-    # @return [Rcom::Node]
-    attr_reader :node
-    # @return [String]
-    attr_reader :service
+  class Request
+    attr_reader :node, :channel
 
-    # @param params [Hash]
-    # @option params :node [Rcom::Node] Example: Rcom::Node.new('local').connect
-    # @option params :service [String] Example: 'auth'
     def initialize(params)
       @node = params[:node]
-      @service = params[:service]
+      @channel = params[:channel]
     end
 
-    # @param params [Hash]
-    # @option params :route [String] Example: 'users.key'
-    # @option params :args Example: 1
-    # @return [reply, nil] Returns the reply or nil if the
-    # request can't be processed.
-    def request(params)
+    def method_missing(name, args)
       begin
         request = {
           id: SecureRandom.hex,
-          route: params[:route],
-          args: params[:args] || ''
+          method: name,
+          args: args || ''
         }
 
-        node.rpush(service, request.to_msgpack)
+        node.rpush(channel, request.to_msgpack)
         ch, response = node.brpop(request[:id], timeout=10)
 
-        MessagePack.unpack(
-          response,
-          symbolize_keys: true
-        )
+        MessagePack.unpack(response, symbolize_keys: true)
       rescue
         return nil
       end
     end
+  end
+
+  class Response
+    attr_reader :node, :channel, :server
 
-    # Subscribe to the service and listen to requests.
-    # @yieldparam router [Rcom::Router] A router to match the request.
-    def subscribe
+    def initialize(params)
+      @node = params[:node]
+      @channel = params[:channel]
+      @server = params[:server]
+    end
+
+    def serve
       begin
         loop do
-          ch, request = node.brpop(service)
+          ch, request = node.brpop(channel)
 
           message = MessagePack.unpack(
             request,
             symbolize_keys: true
           )
-          router = Rcom::Router.new(message)
-
-          yield router
+          response = send_method(
+            message[:method],
+            message[:args]
+          )
 
-          node.rpush(message[:id], router.reply.to_msgpack)
+          node.rpush(message[:id], response.to_msgpack)
         end
+      rescue
+        sleep 1
+        retry
       rescue Interrupt => _
       end
     end
-  end
-
-  # A router can match on a particular route.
-  class Router
-    attr_accessor :message, :reply
-
-    # @param message [Hash] The message received with the request.
-    def initialize(message)
-      @message = message
-    end
 
-    # @yieldparam args
-    def on(route)
-      return nil unless message[:route] == route
-      yield message[:args]
+    def send_method(method, args)
+      begin
+        server.send(method, args)
+      rescue
+        return nil
+      end
     end
   end
 end

data/lib/rcom/task.rb

@@ -1,32 +1,25 @@
 module Rcom
-  # Implements tasks and queues.
   class Task
-    attr_reader :node, :queue
+    attr_reader :node, :channel
 
-    # @param params [Hash]
-    # @option params :node [Rcom::Node]
-    # @option params :queue [String] Example: 'messages'
     def initialize(params)
       @node = params[:node]
-      @queue = params[:queue]
+      @channel = params[:channel]
     end
 
-    # @param message [Hash]
-    # @return [true, nil] True if the message can be queued, otherwise nil.
     def publish(message)
       begin
-        node.lpush(queue, message.to_msgpack)
+        node.lpush(channel, message.to_msgpack)
         return true
       rescue
         return nil
       end
     end
 
-    # @yieldparam message [Hash] the message received.
     def subscribe
       begin
         loop do
-          ch, request = node.brpop(queue)
+          ch, request = node.brpop(channel)
           message = MessagePack.unpack(
             request,
             symbolize_keys: true

data/lib/rcom/topic.rb

@@ -1,31 +1,24 @@
 module Rcom
-  # Implements pub/sub over topics.
   class Topic
-    attr_reader :node, :key
+    attr_reader :node, :channel
 
-    # @param params [Hash]
-    # @option params :node [Rcom::Node]
-    # @option params :key [String] Example: 'services'
     def initialize(params)
       @node = params[:node]
-      @key = params[:key]
+      @key = params[:channel]
     end
 
-    # @param message [Hash]
-    # @return [true, nil] true if it can be published, otherwise nil.
     def publish(message)
       begin
-        node.publish(key, message.to_msgpack)
+        node.publish(channel, message.to_msgpack)
         return true
       rescue
         return nil
       end
     end
 
-    # @yieldparam message [Hash] the message received.
     def subscribe
       begin
-        node.subscribe(key) do |on|
+        node.subscribe(channel) do |on|
           on.message do |channel, message|
             message = MessagePack.unpack(
               message,
@@ -34,6 +27,9 @@ module Rcom
             yield message
           end
         end
+      rescue
+        sleep 1
+        retry
       rescue Interrupt => _
       end
     end

data/lib/rcom/version.rb

@@ -1,3 +1,3 @@
 module Rcom
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/rcom.gemspec

@@ -20,7 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "yard"
 
   spec.add_dependency "redis", "~> 3.1.0"
   spec.add_dependency "msgpack", "~> 0.5.9"

data/test/spec/rpc_spec.rb

@@ -1,38 +1,70 @@
 require_relative './_init'
 
-describe 'Rpc' do
+describe 'Request' do
   before do
     ENV['LOCAL'] = 'redis://localhost'
     @node = Rcom::Node.new('local').connect
-    @service = Rcom::Rpc.new(node: @node, service: 'auth')
+    @request = Rcom::Request.new(node: @node, channel: 'auth')
   end
 
-  it 'represents a remote procedure call' do
-    @service.must_be_instance_of Rcom::Rpc
+  it 'represents a request' do
+    @request.must_be_instance_of Rcom::Request
   end
+end
 
-  it 'returns nil if the request cannot be processed' do
-    @service.request(route: 'nonexistent').must_equal nil
+describe 'Response' do
+  before do
+    ENV['LOCAL'] = 'redis://localhost'
+    @node = Rcom::Node.new('local').connect
+    @response = Rcom::Response.new(
+      node: @node,
+      channel: 'auth',
+      server: nil
+    )
   end
 
-  it 'works in a request/response scenario' do
-    user_key = 'xxxccc'
-    response = ''
-    publisher = 'bundle exec ruby test/bin/rpc_publisher.rb'
-    consumer = 'bundle exec ruby test/bin/rpc_consumer.rb'
+  it 'represents a response' do
+    @response.must_be_instance_of Rcom::Response
+  end
+end
 
-    # Spawn consumer and wait for requests.
-    consumer_pid = spawn(consumer)
+describe 'Request-Response' do
+  before do
+    ENV['LOCAL'] = 'redis://localhost'
+    @node = Rcom::Node.new('local').connect
+
+    @service = Rcom::Request.new(node: @node, channel: 'auth')
+
+    @rpc_server = fork {
+      class Server
+        def get_key(params)
+          user = params[:user]
+          return nil unless user == 1
+          return 'xxxccc'
+        end
+      end
+      auth = Rcom::Response.new(
+        node: @node,
+        channel: 'auth',
+        server: Server.new
+      )
+      auth.serve
+    }
+
+    Process.detach @rpc_server
     sleep 1
+  end
+
+  it 'cannot request method that does not exists' do
+    @service.get_nonexistent(1).must_equal nil
+  end
+
+  it 'can request a method with the correct hash param' do
+    @service.get_key(user: 1).must_equal 'xxxccc'
+  end
 
-    # Spawn a request and record stdout,
-    # then kill both consumer and publisher.
-    Open3.popen3(publisher) do |stdin, stdout, stderr, thr|
-      response = stdout.gets
-      Process.kill('INT', thr.pid)
-    end
-    Process.kill('INT', consumer_pid)
 
-    eval(response.chomp).must_equal user_key
+  after do
+    Process.kill('INT', @rpc_server)
   end
 end

data/test/spec/task_spec.rb

@@ -4,41 +4,35 @@ describe 'Task' do
   before do
     ENV['LOCAL'] = 'redis://localhost'
     @node = Rcom::Node.new('local').connect
-    @task = Rcom::Task.new(node: @node, queue: 'messages')
+    @task = Rcom::Task.new(node: @node, channel: 'messages')
   end
 
   it 'represents a Task' do
     @task.must_be_instance_of Rcom::Task
   end
 
-  it 'can pubish a task' do
-    message = {
+  it 'can publishe a task and subscribe to receive it' do
+    original_message = {
       id: 1,
       key: 'xxxccc'
     }
-    @task.publish(message).must_equal true
-  end
+    reader, writer = IO.pipe
 
-  it 'works in a pub/consumer scenario' do
-    message = {
-      id: 1,
-      key: 'xxxccc'
+    @subscriber = fork {
+      @task.subscribe do |message|
+        writer.write message
+      end
     }
-    completed_job = ''
-    publisher = 'bundle exec ruby test/bin/task_publisher.rb'
-    consumer = 'bundle exec ruby test/bin/task_consumer.rb'
+    Process.detach @subscriber
+    sleep 1
+
+    @task.publish(original_message)
+    sleep 1
 
-    # Start the consumer, wait for it to be up,
-    # start the publisher and wait for the message
-    # on the consumer side. Process, then kill
-    # the long-running consumer.
-    Open3.popen3(consumer) do |stdin, stdout, stderr, wait_thr|
-      sleep 1
-      spawn(publisher)
-      completed_job = stdout.gets
-      Process.kill('INT', wait_thr.pid)
-    end
+    Process.kill('INT', @subscriber)
 
-    eval(completed_job.chomp).must_equal message
+    writer.close
+    eval(reader.read).must_equal original_message
+    reader.close
   end
 end

data/test/spec/topic_spec.rb

@@ -4,7 +4,7 @@ describe 'Topic' do
   before do
     ENV['LOCAL'] = 'redis://localhost'
     @node = Rcom::Node.new('local').connect
-    @topic = Rcom::Topic.new(node: @node, key: 'users')
+    @topic = Rcom::Topic.new(node: @node, channel: 'users')
   end
 
   it 'represents a Topic' do
@@ -19,27 +19,28 @@ describe 'Topic' do
     @topic.publish(message).must_equal true
   end
 
-  it 'works in a pub/sub scenario' do
-    message = {
+  it 'can subscribe to a channel and receive a message' do
+    original_message = {
       id: 1,
       key: 'xxxccc'
     }
-    read_message = ''
-    publisher = 'bundle exec ruby test/bin/topic_publisher.rb'
-    subscriber = 'bundle exec ruby test/bin/topic_subscriber.rb'
-
-    # Start the subscriber, wait for it to be up,
-    # start the publisher and wait for the message
-    # on the subscriber side. Then kill
-    # the long-running subscriber.
-    Open3.popen3(subscriber) do |stdin, stdout, stderr, wait_thr|
-      sleep 2
-      spawn(publisher)
-      read_message = stdout.gets
-      Process.kill('INT', wait_thr.pid)
-    end
-
-    output = eval(read_message.chomp)
-    output.must_equal message
+    reader, writer = IO.pipe
+
+    @subscriber = fork {
+      @topic.subscribe do |message|
+        writer.write message
+      end
+    }
+    Process.detach @subscriber
+    sleep 1
+
+    @topic.publish(original_message)
+    sleep 1
+
+    Process.kill('INT', @subscriber)
+
+    writer.close
+    eval(reader.read).must_equal original_message
+    reader.close
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rcom
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Marco Lisci
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-10 00:00:00.000000000 Z
+date: 2014-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  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: redis
   requirement: !ruby/object:Gem::Requirement
@@ -100,12 +86,6 @@ files:
 - lib/rcom/topic.rb
 - lib/rcom/version.rb
 - rcom.gemspec
-- test/bin/rpc_consumer.rb
-- test/bin/rpc_publisher.rb
-- test/bin/task_consumer.rb
-- test/bin/task_publisher.rb
-- test/bin/topic_publisher.rb
-- test/bin/topic_subscriber.rb
 - test/spec/_init.rb
 - test/spec/node_spec.rb
 - test/spec/rpc_spec.rb
@@ -136,15 +116,8 @@ signing_key:
 specification_version: 4
 summary: Redis inter-service messaging.
 test_files:
-- test/bin/rpc_consumer.rb
-- test/bin/rpc_publisher.rb
-- test/bin/task_consumer.rb
-- test/bin/task_publisher.rb
-- test/bin/topic_publisher.rb
-- test/bin/topic_subscriber.rb
 - test/spec/_init.rb
 - test/spec/node_spec.rb
 - test/spec/rpc_spec.rb
 - test/spec/task_spec.rb
 - test/spec/topic_spec.rb
-has_rdoc: 

data/test/bin/rpc_consumer.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-ENV['LOCAL'] = 'redis://localhost'
-
-require 'rcom'
-
-node = Rcom::Node.new('local').connect
-auth = Rcom::Rpc.new(node: node, service: 'auth')
-
-auth.subscribe do |request|
-  request.on('user.key') do |params|
-    request.reply = 'xxxccc'
-  end
-end

data/test/bin/rpc_publisher.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-ENV['LOCAL'] = 'redis://localhost'
-
-require 'rcom'
-
-message = {
-  route: 'user.key',
-  args: 1
-}
-node = Rcom::Node.new('local').connect
-auth = Rcom::Rpc.new(node: node, service: 'auth')
-p auth.request(message)

data/test/bin/task_consumer.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-ENV['LOCAL'] = 'redis://localhost'
-
-require 'rcom'
-
-node = Rcom::Node.new('local').connect
-messages = Rcom::Task.new(node: node, queue: 'messages')
-
-messages.subscribe do |message|
-  sleep 1
-  p message
-end

data/test/bin/task_publisher.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-ENV['LOCAL'] = 'redis://localhost'
-
-require 'rcom'
-
-message = {
-  id: 1,
-  key: 'xxxccc'
-}
-node = Rcom::Node.new('local').connect
-messages = Rcom::Task.new(node: node, queue: 'messages')
-messages.publish(message)

data/test/bin/topic_publisher.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-ENV['LOCAL'] = 'redis://localhost'
-
-require 'rcom'
-
-message = {
-  id: 1,
-  key: 'xxxccc'
-}
-node = Rcom::Node.new('local').connect
-users = Rcom::Topic.new(node: node, key: 'users')
-
-users.publish(message)

data/test/bin/topic_subscriber.rb

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-ENV['LOCAL'] = 'redis://localhost'
-
-require 'rcom'
-
-node = Rcom::Node.new('local').connect
-users = Rcom::Topic.new(node: node, key: 'users')
-
-users.subscribe do |message|
-  p message
-end