gilmour 0.3.4 → 0.4.1

data/test/spec/test_subscriber_redis_reply_slot_fork.rb

@@ -0,0 +1,274 @@
+# encoding: utf-8
+require 'rspec/given'
+require 'securerandom'
+require './testservice/test_service_base'
+
+require_relative 'helpers/common'
+require_relative 'helpers/connection'
+
+def install_test_subscriber
+  waiter = Waiter.new
+  TestReplier.callback do |topic, data|
+    @topic = topic
+    @data = data
+    waiter.signal
+  end
+  waiter
+end
+
+describe 'TestReplier' do
+  opts = redis_connection_options
+  opts[:broadcast_errors] = true
+
+  test_subscriber_path = './testservice/subscribers/test_reply'
+  after(:all) do
+    EM.stop
+  end
+  Given(:subscriber) { TestServiceBase }
+  Given do
+    subscriber.load_subscriber(test_subscriber_path)
+    subscriber.subscribers.each do |topic, arr|
+      arr.each do |s|
+        s[:fork] = true
+      end
+    end
+  end
+  Then do
+    handlers = subscriber.subscribers(TestReplier::Topic)
+    module_present = handlers.find { |h| h[:subscriber] == TestReplier }
+    module_present.should be_truthy
+  end
+
+  context 'Running Service' do
+    before(:all) do
+      @service = TestServiceBase.new(opts, 'redis')
+    end
+    Given(:connection_opts) { opts }
+    before(:all) do
+      @service.registered_subscribers.each do |s|
+        s.backend = 'redis'
+      end
+      @service.start
+    end
+
+    context 'Handler Register' do
+      When { install_test_subscriber }
+      context 'Check registered handlers' do
+        When(:handlers) do
+          subscriber.subscribers(TestReplier::Simulation)
+          .map { |h| h[:handler] }
+        end
+        Then { handlers.each { |h| h.should be_kind_of Proc } }
+        Then  do
+          arg1 = TestReplier::Simulation
+          handlers.each do |h|
+            arg2 = SecureRandom.hex
+            # simualate a handler call
+            h.call(arg1, arg2)
+            @topic.should be == arg1
+            @data.should be == arg2
+          end
+        end
+      end
+    end
+
+    context 'Publisher side timeout' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        code = nil
+        waiter_code = Waiter.new
+
+        sub.request!(3, TestReplier::TimeoutTopic, {:timeout => 1}) do |d, c|
+          code = c
+          waiter_code.signal
+        end
+
+        waiter_code.wait(5)
+        code
+      end
+      Then do
+        code.should be == 499
+      end
+    end
+
+    context 'Handler sleeps longer than the Timeout' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        waiter_error = Waiter.new
+        waiter_code = Waiter.new
+        code = nil
+
+        backend = @service.get_backend("redis")
+        backend.broadcast_errors = true
+        sub.slot Gilmour::ErrorChannel do
+          waiter_error.signal
+        end
+
+        sub.request!(3, TestReplier::TimeoutTopic) do |d, c|
+          code = c
+          waiter_code.signal
+        end
+
+        waiter_code.wait(5)
+        waiter_error.wait(5)
+
+        backend.broadcast_errors = false
+        code
+      end
+      Then do
+        code.should be == 504
+      end
+    end
+
+    context 'Handler sleeps just enough to survive the timeout' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        waiter = Waiter.new
+        code = nil
+
+        sub.request!(1, TestReplier::TimeoutTopic) do |d, c|
+          code = c
+          waiter.signal
+        end
+
+        waiter.wait(5)
+        code
+      end
+      Then do
+        code.should be == 200
+      end
+    end
+
+
+    context 'Request! sans subscriber error' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:response) do
+        waiter = Waiter.new
+        data = code = nil
+        sub.request!(ping_opts[:message], "hello.world") do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait(5)
+        [data, code]
+      end
+      Then do
+        data, code = response
+        data.should be == nil
+        code.should be == 404
+      end
+
+    end
+
+    context 'Send and receive a message' do
+      Given(:ping_opts) { redis_ping_options }
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:response) do
+        waiter = Waiter.new
+        data = code = nil
+        sub.request!(ping_opts[:message], TestReplier::Topic) do |d, c|
+          data = d
+          code = c
+          waiter.signal
+        end
+        waiter.wait(5)
+        [data, code]
+      end
+      Then do
+        data, code = response
+        data.should be == ping_opts[:response]
+        code.should be == 200
+      end
+    end
+
+    context 'Send once, Receive twice' do
+      Given(:ping_opts) { redis_ping_options }
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When (:response) do
+        waiter = Waiter.new
+
+        actual_ret = []
+
+        group_proc = sub.slot TestReplier::GroupReturn do
+          actual_ret.push(request.body)
+          waiter.signal if actual_ret.length == 4
+        end
+
+        sub.signal!(ping_opts[:message], TestReplier::GroupTopic)
+        waiter.wait(5)
+
+        sub.remove_slot TestReplier::GroupReturn, group_proc
+        actual_ret
+      end
+      Then do
+        response.select { |e| e == ping_opts[:message] }.size.should == 2
+        response.select { |e| e == "2" }.size.should == 2
+      end
+    end
+
+    context 'Handler to Test exits' do
+      Given(:ping_opts) do
+        redis_ping_options
+      end
+
+      When(:sub) do
+        Gilmour::RedisBackend.new({})
+      end
+      When(:code) do
+        waiter_error = Waiter.new
+        waiter_code = Waiter.new
+        code = nil
+
+        #backend = @service.get_backend("redis")
+        #backend.broadcast_errors = true
+        error_listener_proc = sub.slot Gilmour::ErrorChannel do |d, c|
+          waiter_error.signal
+        end
+
+        sub.request!(1, TestReplier::ExitTopic) do |d, c|
+          code = c
+          waiter_code.signal
+        end
+
+        waiter_code.wait(5)
+        waiter_error.wait(5)
+
+        sub.remove_listener Gilmour::ErrorChannel, error_listener_proc
+        #backend.broadcast_errors = false
+        code
+      end
+      Then do
+        code.should be == 500
+      end
+    end
+  end
+end

data/test/spec/test_waiter.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require 'rspec/given'
+
+require '../lib/gilmour/waiter'
+
+describe 'TestAddGroup' do
+  context "Wait Group" do
+    it "Wait should return instantly" do
+      wg = Gilmour::Waiter.new
+
+      num = 2
+      arr = []
+
+      num.times do
+        wg.add 1
+        Thread.new {
+          arr << "done"
+          wg.done
+        }
+      end
+
+      wg.wait
+      expect(arr.length).to eq num
+    end
+
+    it "Wait should return after sleep" do
+      wg = Gilmour::Waiter.new
+
+      num = 2
+      arr = []
+
+      num.times do
+        wg.add 1
+        Thread.new {
+          sleep(1)
+          arr << true
+          wg.done
+        }
+      end
+
+      wg.wait
+      expect(arr.length).to eq num
+    end
+
+    it "Wait should perform a yield" do
+      wg = Gilmour::Waiter.new
+
+      num = 2
+      arr = []
+
+      num.times do
+        wg.add 1
+        Thread.new {
+          sleep(1)
+          arr << true
+          wg.done
+        }
+      end
+
+      wg.wait do
+        arr << true
+      end
+
+      expect(arr.length).to eq num+1
+    end
+
+    it "Wait should timeout" do
+      wg = Gilmour::Waiter.new
+
+      num = 2
+      arr = []
+
+      num.times do
+        wg.add 1
+        Thread.new {
+          sleep(2)
+          arr << true
+          wg.done
+        }
+      end
+
+      wg.wait(1) do
+        arr << true
+      end
+
+      expect(arr.length).to eq 1
+    end
+
+    it "Done and Wait only" do
+      wg = Gilmour::Waiter.new
+
+      arr = []
+
+      Thread.new {
+        sleep(2)
+        arr << true
+        wg.done
+      }
+
+      wg.wait do
+        arr << true
+      end
+
+      expect(arr.length).to eq 2
+    end
+
+    it "Signal should raise when using add" do
+      wg = Gilmour::Waiter.new
+      wg.add 1
+      expect{wg.signal}.to raise_error(RuntimeError)
+    end
+
+  end
+end

data/test/testservice/subscribers/test_reply.rb

@@ -0,0 +1,69 @@
+class TestReplier < TestServiceBase
+  TimeoutTopic = "test.reply.timeout"
+  Topic = 'test.reply.topic'
+  WildcardTopic = 'test.reply.wildcard.*'
+  Simulation = 'simulate.reply.topic'
+  Republish = 'test.reply.republish'
+  GroupReturn = "test.slot.group_return"
+  GroupTopic = "test.slot.group"
+  ExclusiveTopic = "test.reply.exclusive"
+  ExitTopic = "topic.reply.exit"
+  ReListenTopic = "topic.reply.relisten"
+
+
+  def self.get_callback
+    @callback
+  end
+
+  def self.callback
+    @callback = Proc.new
+  end
+
+  
+  2.times do
+    slot GroupTopic do
+      signal!(request.body, TestReplier::GroupReturn)
+      signal!("2", TestReplier::GroupReturn)
+    end
+  end
+
+  reply_to TimeoutTopic, {timeout: 2} do
+    data, _, _ = Gilmour::Protocol.parse_response(request.body)
+    logger.info "Will sleep for #{data} seconds now. But allowed timeout is 2."
+    sleep data
+    respond 'Pong!'
+    logger.info "Done with sleep"
+  end
+
+  reply_to ExitTopic do
+    logger.info "Sleeping for 2 seconds, and then will exit"
+    exit!
+  end
+
+  reply_to ReListenTopic do
+    # In forked environment this should not work.
+    reply_to "test.world", excl_group: 'relisten' do
+      respond "Pong!"
+    end
+    respond "Pong"
+  end
+
+  reply_to Topic do
+    if TestReplier.get_callback
+      TestReplier.get_callback.call(request.topic, request.body)
+    end
+    respond 'Pong!' if request.body == 'Ping!'
+  end
+
+  reply_to Simulation do |topic, data|
+    @callback.call(topic, data)
+  end
+
+  reply_to Republish do
+    resp = self
+    request!(request.body, Topic) do |data, code|
+      resp.respond data, 200, now: true
+    end
+    delay_response
+  end
+end

data/test/testservice/subscribers/test_subscriber.rb

@@ -99,5 +99,6 @@ class TestSubscriber < TestServiceBase
     publish(request.body, Topic) do |data, code|
       resp.respond data, 200, now: true
     end
+    delay_response
   end
 end

data/version.rb

@@ -1,3 +1,3 @@
 module Gilmour
-    VERSION = '0.3.4'
+    VERSION = '0.4.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gilmour
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.1
 platform: ruby
 authors:
 - Aditya Godbole
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-31 00:00:00.000000000 Z
+date: 2015-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -109,24 +109,33 @@ files:
 - Gemfile
 - LICENSE
 - README.md
+- examples/composition.rb
+- examples/container.rb
 - examples/echoclient.rb
-- examples/fork_log_server.rb
-- examples/server.rb
-- examples/thread_example.rb
+- examples/fibonacci.rb
+- examples/forkechoclient.rb
+- examples/signal_slot.rb
+- examples/subscribers/echo.rb
 - gilmour.gemspec
 - lib/gilmour.rb
 - lib/gilmour/backends/backend.rb
 - lib/gilmour/backends/redis.rb
 - lib/gilmour/base.rb
+- lib/gilmour/composers.rb
 - lib/gilmour/protocol.rb
 - lib/gilmour/responder.rb
 - lib/gilmour/waiter.rb
 - test/spec/helpers/common.rb
 - test/spec/helpers/connection.rb
 - test/spec/helpers/data.yml
+- test/spec/test_pipelines.rb
 - test/spec/test_service_base.rb
 - test/spec/test_subscriber_redis.rb
 - test/spec/test_subscriber_redis_forked.rb
+- test/spec/test_subscriber_redis_reply_slot.rb
+- test/spec/test_subscriber_redis_reply_slot_fork.rb
+- test/spec/test_waiter.rb
+- test/testservice/subscribers/test_reply.rb
 - test/testservice/subscribers/test_subscriber.rb
 - test/testservice/test_service_base.rb
 - version.rb
@@ -157,8 +166,13 @@ test_files:
 - test/spec/helpers/common.rb
 - test/spec/helpers/connection.rb
 - test/spec/helpers/data.yml
+- test/spec/test_pipelines.rb
 - test/spec/test_service_base.rb
 - test/spec/test_subscriber_redis.rb
 - test/spec/test_subscriber_redis_forked.rb
+- test/spec/test_subscriber_redis_reply_slot.rb
+- test/spec/test_subscriber_redis_reply_slot_fork.rb
+- test/spec/test_waiter.rb
+- test/testservice/subscribers/test_reply.rb
 - test/testservice/subscribers/test_subscriber.rb
 - test/testservice/test_service_base.rb

data/examples/fork_log_server.rb

@@ -1,97 +0,0 @@
-# encoding: utf-8
-require_relative '../lib/gilmour'
-
-class EventServer
-  include Gilmour::Base
-
-  def initialize
-    backend = 'redis'
-    enable_backend(backend, { })
-    registered_subscribers.each do |sub|
-      sub.backend = backend
-    end
-    $stderr.puts "Starting server. To see messaging in action run clients."
-    start(true)
-  end
-end
-
-class EchoSubscriber < EventServer
-  class << self
-    def capture_output(pipe)
-      streams = [$stdout, $stderr]
-
-      # Save the streams to be reassigned later.
-      # Actually it doesn't matter because the child process would be killed
-      # anyway after the work is done.
-      saved = streams.collect { |stream| stream.dup }
-
-      begin
-        streams.each_with_index do |stream, ix|
-          # Probably I should not use IX, otherwise stdout and stderr can arrive
-          # out of order, which they should?
-          # If I reopen both of them on the same PIPE, they are guaranteed to
-          # arrive in order.
-          stream.reopen(pipe)
-          #stream.sync = true
-        end
-        yield
-      ensure
-        # This is sort of meaningless, just makes sense aesthetically.
-        # To return what was borrowed.
-        streams.each_with_index do |stream, i|
-          stream.reopen(saved[i])
-        end
-        pipe.close unless pipe.closed?
-      end
-    end
-
-    def ds_respond(topic, opts={}, &blk)
-      options = { exclusive: true, fork: true }.merge(opts)
-      listen_to topic, options do
-        logger.error "Captuting output before execution"
-
-        waiter = Gilmour::Waiter.new
-        waiter.add 1
-        read_pipe, write_pipe = IO.pipe
-
-        th = Thread.new {
-          loop {
-            begin
-              result = read_pipe.readline.chomp
-              logger.debug result
-            rescue EOFError
-              waiter.done
-            rescue Exception => e
-              logger.error "Error: #{e.message}"
-              logger.error "Traceback: #{e.backtrace}"
-            end
-          }
-        }
-
-        EchoSubscriber::capture_output(write_pipe) do
-          instance_eval(&blk)
-        end
-
-        waiter.wait do
-          th.kill
-        end
-
-      end
-    end
-  end
-
-  # Passing second parameter as true makes only one instance of this handler handle a request
-  EchoSubscriber::ds_respond 'echo.*' do
-    if request.body == 'Palmolive'
-      respond nil
-    else
-      logger.error "logger: #{request.body}"
-      $stderr.puts "stderr.puts: #{request.body}"
-      puts "stdout.puts #{request.body}"
-      respond "#{request.topic}"
-    end
-  end
-
-end
-
-EventServer.new

data/examples/server.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-require 'gilmour'
-
-class EventServer
-  include Gilmour::Base
-
-  def initialize
-    backend = 'redis'
-    enable_backend(backend, { })
-    registered_subscribers.each do |sub|
-      sub.backend = backend
-    end
-    $stderr.puts "Starting server. To see messaging in action run clients."
-    start(true)
-  end
-end
-
-class EchoSubscriber < EventServer
-  # Passing second parameter as true makes only one instance of this handler handle a request
-  listen_to 'echo.*', {"exclusive" => true} do
-    if request.body == 'Palmolive'
-      respond nil
-    else
-      $stderr.puts request.body
-      respond "#{request.topic}"
-    end
-  end
-end
-
-class FibonacciSubscriber < EventServer
-  class << self
-    attr_accessor :last
-  end
-
-  listen_to 'fib.next' do
-    old = FibonacciSubscriber.last
-    FibonacciSubscriber.last = new = request.body
-    respond(old + new)
-  end
-
-  listen_to 'fib.init' do
-    FibonacciSubscriber.last = request.body
-  end
-
-end
-
-EventServer.new