tochtli 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56acd327a8d04ef8de6ca2ab8a2b677e27e276e4
-  data.tar.gz: c0f076e6906b0ef7a401585be0946ec1b8b0d1f3
+  metadata.gz: d7a4aeafb78f7399f7f0f7444bcae42b8a025fa6
+  data.tar.gz: 5d387cebbd67b3323ee3ef60e7f2eac1d6cc7087
 SHA512:
-  metadata.gz: 4653fc71fcd32d2a9a21bb9929d9994564b2b3b5e1a680e04faf414705ad7bf9b9bcc8e12e274d653183f2fec2780adb3d872a93c004123c611820479d95cd97
-  data.tar.gz: 4e799d6d4888f1182772ca63dfdcd534fa2255f50926a98bb2a3df8ba1fd0b5b8b897361227e785dfdb5287269400ecac5cae7be9925f6cd2babf2350889fdb9
+  metadata.gz: 556377482683580c625cbf00a34f100bbf03fd8a0c3338b7f6a10efba216283d27be4389dca208168a47923ea08dd72f68710bddafd2271c60c32a3f83100bd0
+  data.tar.gz: c7b5e7dee6939180abe8981e110c87d02e62fefa223971f32aa46bd27ce72ddb7fa605bf944ca7107f1f3cf52ba9f8638195ec687327461243768a0302c4f572

data/History.md

@@ -1,3 +1,7 @@
+## 0.5.1 / 2015-08-19
+
+  * [Integration Tests] Fix controller manager restart - some controllers are fixed to the test connection after functional tests
+
 ## 0.5.0 / 2015-08-19
 
   * Usage examples

data/README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://travis-ci.org/PuzzleFlow/tochtli.svg?branch=master)](https://travis-ci.org/PuzzleFlow/tochtli)
+[![Gem Version](https://badge.fury.io/rb/tochtli.svg)](http://badge.fury.io/rb/tochtli)
 
 # What's Tochtli?
 
@@ -43,4 +44,4 @@ Read more about Tochtli and go through the tutorial on [Tochtli homepage](http:/
 
 # License
 
-Released under the MIT license.
+Released under the MIT license.

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/examples/01-screencap-service/client.rb

@@ -3,13 +3,13 @@ require_relative 'common'
 Tochtli.logger.progname = 'CLIENT'
 
 class ScreenerClient < Tochtli::BaseClient
-	def create_screen(url, file_name)
-		handler = SyncMessageHandler.new
-		message = CreateScreenMessage.new(url: url, file: file_name)
-		rabbit_client.publish message, handler: handler
-		handler.wait!(20)
-		puts "Done in #{handler.reply.time} seconds"
-	end
+  def create_screen(url, file_name)
+    handler = SyncMessageHandler.new
+    message = CreateScreenMessage.new(url: url, file: file_name)
+    rabbit_client.publish message, handler: handler
+    handler.wait!(20)
+    puts "Done in #{handler.reply.time} seconds"
+  end
 end
 
 ScreenerClient.new.create_screen(ARGV[0], ARGV[1])

data/examples/01-screencap-service/common.rb

@@ -4,12 +4,12 @@ Bundler.require
 Tochtli.logger = Logger.new('tochtli.log')
 
 class CreateScreenMessage < Tochtli::Message
-	route_to 'screener.create'
+  route_to 'screener.create'
 
-	attribute :url, String
-	attribute :file, String
+  attribute :url, String
+  attribute :file, String
 end
 
 class CreateScreenReplyMessage < Tochtli::Message
-	attribute :time, Float
+  attribute :time, Float
 end

data/examples/01-screencap-service/server.rb

@@ -3,17 +3,17 @@ require_relative 'common'
 Tochtli.logger.progname = 'SERVER'
 
 class ScreenerController < Tochtli::BaseController
-	bind 'screener.*'
+  bind 'screener.*'
 
-	on CreateScreenMessage, :create
+  on CreateScreenMessage, :create
 
-	def create
-		start_time = Time.now
-		f = Screencap::Fetcher.new(message.url)
-		f.fetch output: File.join(__dir__, 'images', message.file)
-		total_time = Time.now - start_time
-		reply CreateScreenReplyMessage.new(time: total_time)
-	end
+  def create
+    start_time = Time.now
+    f = Screencap::Fetcher.new(message.url)
+    f.fetch output: File.join(__dir__, 'images', message.file)
+    total_time = Time.now - start_time
+    reply CreateScreenReplyMessage.new(time: total_time)
+  end
 end
 
 Tochtli::ControllerManager.setup

data/examples/02-log-analyzer/client.rb

@@ -9,9 +9,9 @@ module LogAnalyzer
     end
 
     def react_on_events(client_id, severities, handler=nil, &block)
-	    handler = block unless handler
+      handler = block unless handler
       severities = Array(severities)
-	    routing_keys = severities.map {|severity| "log.events.#{severity}" }
+      routing_keys = severities.map {|severity| "log.events.#{severity}" }
       Tochtli::ControllerManager.start EventsController,
                                        queue_name: "log_analyzer/events/#{client_id}", # custom queue name
                                        routing_keys: routing_keys, # make custom binding (only selected severities)
@@ -19,7 +19,7 @@ module LogAnalyzer
     end
 
     def monitor_status(monitor=nil, &block)
-	    monitor = block unless monitor
+      monitor = block unless monitor
       Tochtli::ControllerManager.start MonitorController, env: { monitor: monitor }
     end
   end
@@ -27,18 +27,18 @@ module LogAnalyzer
   protected
 
   class EventsController < Tochtli::BaseController
-	  on EventOccurred, :handle, routing_key: 'log.events.*'
+    on EventOccurred, :handle, routing_key: 'log.events.*'
 
     def handle
-	    handler.call(message.severity, message.timestamp, message.message)
+      handler.call(message.severity, message.timestamp, message.message)
     end
 
-		protected
+    protected
 
-		def handler
-			raise "Internal Error: handler not set for EventsController" unless env.has_key?(:handler)
-			env[:handler]
-		end
+    def handler
+      raise "Internal Error: handler not set for EventsController" unless env.has_key?(:handler)
+      env[:handler]
+    end
   end
 
   class MonitorController < Tochtli::BaseController
@@ -50,14 +50,14 @@ module LogAnalyzer
     self.queue_auto_delete = true
 
     on CurrentStatus do
-	    monitor.call(message.to_hash)
+      monitor.call(message.to_hash)
     end
 
     protected
 
     def monitor
-	    raise "Internal Error: monitor not set for MonitorController" unless env.has_key?(:monitor)
-	    env[:monitor]
+      raise "Internal Error: monitor not set for MonitorController" unless env.has_key?(:monitor)
+      env[:monitor]
     end
   end
 end
@@ -66,30 +66,30 @@ client = LogAnalyzer::Client.new
 command = ARGV[0]
 
 def hold
-	puts 'Press Ctrl-C to stop...'
-	sleep
+  puts 'Press Ctrl-C to stop...'
+  sleep
 end
 
 
 case command
-	when 's'
-		client.send_new_log ARGV[1]
-	when 'm'
-		client.monitor_status {|status| p status }
-		hold
-	when 'c'
-		client.react_on_events ARGV[1], [:fatal, :error], lambda {|severity, timestamp, message|
-			puts "[#{timestamp}] Got #{severity}: #{message}"
-		}
-		hold
-	else
-		puts "Unknown command: #{command.inspect}"
-		puts
-		puts "Usage: bundle exec ruby client [command] [params]"
-		puts
-		puts "Commands:"
-		puts "  s [path]      - send log from file to server"
-		puts "  m             - start status monitor"
-		puts "  c [client ID] - catch fatal and error events"
+  when 's'
+    client.send_new_log ARGV[1]
+  when 'm'
+    client.monitor_status {|status| p status }
+    hold
+  when 'c'
+    client.react_on_events ARGV[1], [:fatal, :error], lambda {|severity, timestamp, message|
+      puts "[#{timestamp}] Got #{severity}: #{message}"
+    }
+    hold
+  else
+    puts "Unknown command: #{command.inspect}"
+    puts
+    puts "Usage: bundle exec ruby client [command] [params]"
+    puts
+    puts "Commands:"
+    puts "  s [path]      - send log from file to server"
+    puts "  m             - start status monitor"
+    puts "  c [client ID] - catch fatal and error events"
 end
 

data/examples/02-log-analyzer/server.rb

@@ -14,8 +14,8 @@ module LogAnalyzer
     cattr_accessor :monitor
 
     after_setup do |rabbit_connection|
-	    self.monitor = StatusMonitor.new(rabbit_connection)
-	    self.monitor.start
+      self.monitor = StatusMonitor.new(rabbit_connection)
+      self.monitor.start
     end
 
     def create
@@ -68,11 +68,11 @@ module LogAnalyzer
   end
 
   class EventNotifier < Tochtli::BaseClient
-		SIGNIFICANT_SEVERITIES = [:fatal, :error, :warn]
+    SIGNIFICANT_SEVERITIES = [:fatal, :error, :warn]
 
-		def self.significant?(severity)
-			SIGNIFICANT_SEVERITIES.include?(severity)
-		end
+    def self.significant?(severity)
+      SIGNIFICANT_SEVERITIES.include?(severity)
+    end
 
     def notify(event)
       publish EventOccurred.new(event), mandatory: false
@@ -105,18 +105,18 @@ module LogAnalyzer
     protected
 
     def reset_status
-	    synchronize do
-		    status = @status
-		    @status = Hash.new(0)
-		    status
-	    end
+      synchronize do
+        status = @status
+        @status = Hash.new(0)
+        status
+      end
     end
 
     def monitor
       loop do
         current_status = reset_status
         current_status[:timestamp] = Time.now
-		    @notifier.update_status current_status
+        @notifier.update_status current_status
         sleep 10
       end
     end

data/lib/tochtli.rb

@@ -69,9 +69,9 @@ module Tochtli
           @logger       = Logger.new(File.join(Rails.root, 'log/service.log'))
           @logger.level = Rails.env.production? ? Logger::WARN : Logger::DEBUG
         else
-	        @logger       = Logger.new(STDERR)
-	        @logger.level = Logger::WARN
-				end
+          @logger       = Logger.new(STDERR)
+          @logger.level = Logger::WARN
+        end
       end
       @logger
     end

data/lib/tochtli/base_controller.rb

@@ -83,9 +83,9 @@ module Tochtli
       end
 
       def start(queue_name=nil, routing_keys=nil, initial_env={})
-				run_hook :before_start, queue_name, initial_env
+        run_hook :before_start, queue_name, initial_env
         self.dispatcher.start(queue_name || self.queue_name, routing_keys || self.routing_keys, initial_env)
-				run_hook :after_start, queue_name, initial_env
+        run_hook :after_start, queue_name, initial_env
       end
 
       def set_up?
@@ -97,24 +97,30 @@ module Tochtli
       end
 
       def stop(options={})
-	      if started?
-					queues = self.dispatcher.queues
-		      run_hook :before_stop, queues
+        if started?
+          queues = self.dispatcher.queues
+          run_hook :before_stop, queues
+        end
+        
+        if self.dispatcher
+          self.dispatcher.shutdown(options)
+          self.dispatcher = nil
 
-					self.dispatcher.shutdown(options)
-	        self.dispatcher = nil
+          run_hook :after_stop, queues
 
-					run_hook :after_stop, queues
-				end
+          true
+        else
+          false
+        end
       end
 
       def restart(options={})
-	      if started?
-		      queues = self.dispatcher.queues
-		      run_hook :before_restart, queues
-		      self.dispatcher.restart options
-		      run_hook :after_restart, queues
-				end
+        if started?
+          queues = self.dispatcher.queues
+          run_hook :before_restart, queues
+          self.dispatcher.restart options
+          run_hook :after_restart, queues
+        end
       end
 
       def find_message_route(routing_key)
@@ -181,13 +187,13 @@ module Tochtli
     end
 
     def rabbit_connection
-	    self.class.dispatcher.rabbit_connection if self.class.set_up?
+      self.class.dispatcher.rabbit_connection if self.class.set_up?
     end
 
     class MessageRoute < Struct.new(:message_class, :action, :routing_key, :pattern)
-			def initialize(message_class, action, routing_key)
-				super message_class, action, routing_key, KeyPattern.new(routing_key)
-			end
+      def initialize(message_class, action, routing_key)
+        super message_class, action, routing_key, KeyPattern.new(routing_key)
+      end
     end
 
     class Dispatcher
@@ -209,13 +215,13 @@ module Tochtli
       end
 
       def restart(options={})
-	      queues = @queues.dup
+        queues = @queues.dup
 
-	      shutdown options
+        shutdown options
 
-	      queues.each do |queue_name, queue_opts|
-		      start queue_name, queue_opts[:initial_env]
-	      end
+        queues.each do |queue_name, queue_opts|
+          start queue_name, queue_opts[:initial_env]
+        end
       end
 
       def process_message(delivery_info, properties, payload, initial_env)
@@ -266,15 +272,15 @@ module Tochtli
       rescue Bunny::ConnectionClosedError
         # ignore closed connection error
       ensure
-	      @queues = {}
+        @queues = {}
       end
 
       def started?(queue_name=nil)
-	      if queue_name
-		      @queues.has_key?(queue_name)
-	      else
-		      !@queues.empty?
-	      end
+        if queue_name
+          @queues.has_key?(queue_name)
+        else
+          !@queues.empty?
+        end
       end
 
       def queues
@@ -326,35 +332,35 @@ module Tochtli
     end
 
     class KeyPattern
-			ASTERIX_EXP = '[a-zA-Z0-9]+'
-			HASH_EXP = '[a-zA-Z0-9\.]*'
-
-	    def initialize(pattern)
-				@str = pattern
-				@simple = !pattern.include?('*') && !pattern.include?('#')
-				if @simple
-					@pattern = pattern
-				else
-					@pattern = Regexp.new('^' + pattern.gsub('.', '\\.').
-							gsub('*', ASTERIX_EXP).gsub(/(\\\.)?#(\\\.)?/, HASH_EXP) + '$')
-				end
-	    end
-
-	    def =~(key)
-				if @simple
-					@pattern == key
-				else
-					@pattern =~ key
-				end
-	    end
-
-	    def !~(key)
-		    !(self =~ key)
-	    end
-
-	    def to_s
-		    @str
-	    end
-		end
+      ASTERIX_EXP = '[a-zA-Z0-9]+'
+      HASH_EXP = '[a-zA-Z0-9\.]*'
+
+      def initialize(pattern)
+        @str = pattern
+        @simple = !pattern.include?('*') && !pattern.include?('#')
+        if @simple
+          @pattern = pattern
+        else
+          @pattern = Regexp.new('^' + pattern.gsub('.', '\\.').
+              gsub('*', ASTERIX_EXP).gsub(/(\\\.)?#(\\\.)?/, HASH_EXP) + '$')
+        end
+      end
+
+      def =~(key)
+        if @simple
+          @pattern == key
+        else
+          @pattern =~ key
+        end
+      end
+
+      def !~(key)
+        !(self =~ key)
+      end
+
+      def to_s
+        @str
+      end
+    end
   end
 end

data/lib/tochtli/controller_manager.rb

@@ -26,13 +26,13 @@ module Tochtli
     end
 
     def start(*controllers)
-	    options       = controllers.extract_options!
-	    setup_options = options.except!(:logger, :cache, :connection)
-	    queue_name    = options.delete(:queue_name)
-	    routing_keys  = options.delete(:routing_keys)
-	    initial_env   = options.delete(:env) || {}
+      options       = controllers.extract_options!
+      setup_options = options.except!(:logger, :cache, :connection)
+      queue_name    = options.delete(:queue_name)
+      routing_keys  = options.delete(:routing_keys)
+      initial_env   = options.delete(:env) || {}
 
-	    setup(setup_options) unless set_up?
+      setup(setup_options) unless set_up?
 
       if controllers.empty? || controllers.include?(:all)
         controllers = @controller_classes
@@ -41,34 +41,33 @@ module Tochtli
       controllers.each do |controller_class|
         raise ArgumentError, "Controller expected, got: #{controller_class.inspect}" unless controller_class.is_a?(Class) && controller_class < Tochtli::BaseController
         unless controller_class.started?(queue_name)
-          @logger.info "Starting #{controller_class}..." if @logger
           controller_class.setup(@rabbit_connection, @cache, @logger) unless controller_class.set_up?
           controller_class.start queue_name, routing_keys, initial_env
+          @logger.info "[#{Time.now} AMQP] Started #{controller_class}" if @logger
         end
       end
     end
 
     def stop
       @controller_classes.each do |controller_class|
-        if controller_class.started?
-          @logger.info "Stopping #{controller_class}..." if @logger
-          controller_class.stop
+        if controller_class.stop
+          @logger.info "[#{Time.now} AMQP] Stopped #{controller_class}" if @logger
         end
       end
       @rabbit_connection = nil
     end
 
     def restart(options={})
-	    options[:rabbit_connection] ||= @rabbit_connection
-	    options[:logger]            ||= @logger
-	    options[:cache]             ||= @cache
+      options[:rabbit_connection] ||= @rabbit_connection
+      options[:logger]            ||= @logger
+      options[:cache]             ||= @cache
 
-	    setup options
-	    restart_active_controllers
+      setup options
+      restart_active_controllers
     end
 
     def set_up?
-	    !@rabbit_connection.nil?
+      !@rabbit_connection.nil?
     end
 
     def running?
@@ -78,17 +77,17 @@ module Tochtli
     protected
 
     def restart_active_controllers
-	    @controller_classes.each do |controller_class|
-		    if controller_class.started?
-			    @logger.info "Restarting #{controller_class}..." if @logger
-			    controller_class.restart
-		    end
-	    end
+      @controller_classes.each do |controller_class|
+        if controller_class.started?
+          @logger.info "Restarting #{controller_class}..." if @logger
+          controller_class.restart
+        end
+      end
     end
 
     class << self
       def method_missing(method, *args)
-	      if instance.respond_to?(method)
+        if instance.respond_to?(method)
           instance.send(method, *args)
         else
           super

data/lib/tochtli/message.rb

@@ -88,11 +88,11 @@ module Tochtli
     end
 
     def routing_key
-			if self.class.routing_key.is_a?(Proc)
-				self.instance_eval(&self.class.routing_key)
-			else
+      if self.class.routing_key.is_a?(Proc)
+        self.instance_eval(&self.class.routing_key)
+      else
         self.class.routing_key
-			end
+      end
     end
 
     def to_hash

data/lib/tochtli/test/integration.rb

@@ -16,6 +16,7 @@ module Tochtli
         @client             = Tochtli::RabbitClient.new(nil, @logger)
         @connection         = @client.rabbit_connection
         @controller_manager = Tochtli::ControllerManager.instance
+        @controller_manager.stop # restart all controllers - some can be started with functional tests on test connections
         @controller_manager.setup(connection: @connection, logger: @logger)
         @controller_manager.start(:all)
 

data/log_generator.rb

@@ -5,7 +5,7 @@ SEVERITIES = [:fatal] + [:error]*3 + [:warn]*5 + [:info]*12 + [:debug]*20
 log = Logger.new('sample.log')
 
 10000.times do 
-	severity = SEVERITIES.sample
-	log.send severity, "Sample #{severity}"
+  severity = SEVERITIES.sample
+  log.send severity, "Sample #{severity}"
 end
 

data/test/controller_functional_test.rb

@@ -11,7 +11,7 @@ class ControllerFunctionalTest < Minitest::Test
   end
 
   class CustomTopicMessage < Tochtli::Message
-	  route_to { "fn.test.#{key}.#{action}" }
+    route_to { "fn.test.#{key}.#{action}" }
 
     attribute :resource, String
 
@@ -40,7 +40,7 @@ class ControllerFunctionalTest < Minitest::Test
     off 'fn.test.off.accept'
 
     on CustomTopicMessage, routing_key: 'fn.test.*.reject' do
-	    reply TestCustomReply.new(:message => "#{message.resource} rejected")
+      reply TestCustomReply.new(:message => "#{message.resource} rejected")
     end
 
     def echo

data/test/controller_manager_test.rb

@@ -56,20 +56,20 @@ class ControllerManagerTest < Minitest::Test
     Tochtli::ControllerManager.start(FirstController, connection: @connection, logger: @logger)
   end
 
-	def test_multiple_queues
-		Tochtli::ControllerManager.setup(connection: @connection, logger: @logger)
-		Tochtli::ControllerManager.start(FirstController, queue_name: 'first_queue')
-		Tochtli::ControllerManager.start(FirstController, queue_name: 'second_queue')
+  def test_multiple_queues
+    Tochtli::ControllerManager.setup(connection: @connection, logger: @logger)
+    Tochtli::ControllerManager.start(FirstController, queue_name: 'first_queue')
+    Tochtli::ControllerManager.start(FirstController, queue_name: 'second_queue')
 
-		assert_equal ["first_queue", "second_queue"], FirstController.dispatcher.queues.map(&:name).sort
-	end
+    assert_equal ["first_queue", "second_queue"], FirstController.dispatcher.queues.map(&:name).sort
+  end
 
-	def test_restart_multiple_queues
-		Tochtli::ControllerManager.setup(connection: @connection, logger: @logger)
-		Tochtli::ControllerManager.start(FirstController, queue_name: 'first_queue')
-		Tochtli::ControllerManager.start(FirstController, queue_name: 'second_queue')
-		Tochtli::ControllerManager.restart
+  def test_restart_multiple_queues
+    Tochtli::ControllerManager.setup(connection: @connection, logger: @logger)
+    Tochtli::ControllerManager.start(FirstController, queue_name: 'first_queue')
+    Tochtli::ControllerManager.start(FirstController, queue_name: 'second_queue')
+    Tochtli::ControllerManager.restart
 
-		assert_equal ["first_queue", "second_queue"], FirstController.dispatcher.queues.map(&:name).sort
-	end
+    assert_equal ["first_queue", "second_queue"], FirstController.dispatcher.queues.map(&:name).sort
+  end
 end

data/test/key_matcher_test.rb

@@ -2,99 +2,99 @@ require_relative 'test_helper'
 require 'benchmark'
 
 class MessageTest < Minitest::Test
-	KeyPattern = Tochtli::BaseController::KeyPattern
+  KeyPattern = Tochtli::BaseController::KeyPattern
 
-	def test_simple_pattern
-		pattern = KeyPattern.new('a.b.c')
+  def test_simple_pattern
+    pattern = KeyPattern.new('a.b.c')
 
-		assert_matches pattern, 'a.b.c'
-		refute_matches pattern, 'a.b.c.d'
-		refute_matches pattern, 'b.c.d'
-	end
+    assert_matches pattern, 'a.b.c'
+    refute_matches pattern, 'a.b.c.d'
+    refute_matches pattern, 'b.c.d'
+  end
 
-	def test_asterix_at_start
-		pattern = KeyPattern.new('*.b.c')
+  def test_asterix_at_start
+    pattern = KeyPattern.new('*.b.c')
 
-		assert_matches pattern, 'a.b.c'
-		assert_matches pattern, 'b.b.c'
-		refute_matches pattern, 'a.b.c.d'
-	end
+    assert_matches pattern, 'a.b.c'
+    assert_matches pattern, 'b.b.c'
+    refute_matches pattern, 'a.b.c.d'
+  end
 
-	def test_asterix_in_the_middle
-		pattern = KeyPattern.new('a.*.b.c')
+  def test_asterix_in_the_middle
+    pattern = KeyPattern.new('a.*.b.c')
 
-		assert_matches pattern, 'a.a.b.c'
-		assert_matches pattern, 'a.d.b.c'
-		refute_matches pattern, 'a.b.c.d'
-	end
+    assert_matches pattern, 'a.a.b.c'
+    assert_matches pattern, 'a.d.b.c'
+    refute_matches pattern, 'a.b.c.d'
+  end
 
-	def test_asterix_at_the_end
-		pattern = KeyPattern.new('a.b.c.*')
+  def test_asterix_at_the_end
+    pattern = KeyPattern.new('a.b.c.*')
 
-		assert_matches pattern, 'a.b.c.d'
-		assert_matches pattern, 'a.b.c.a'
-		refute_matches pattern, 'a.b.c'
-		refute_matches pattern, 'a.b.c.d.e'
-	end
+    assert_matches pattern, 'a.b.c.d'
+    assert_matches pattern, 'a.b.c.a'
+    refute_matches pattern, 'a.b.c'
+    refute_matches pattern, 'a.b.c.d.e'
+  end
 
-	def test_hash
-		pattern = KeyPattern.new('#')
+  def test_hash
+    pattern = KeyPattern.new('#')
 
-		assert_matches pattern, ''
-		assert_matches pattern, 'a.b.c'
-		assert_matches pattern, 'a.b.b.c'
-	end
+    assert_matches pattern, ''
+    assert_matches pattern, 'a.b.c'
+    assert_matches pattern, 'a.b.b.c'
+  end
 
-	def test_hash_at_start
-		pattern = KeyPattern.new('#.b.c')
+  def test_hash_at_start
+    pattern = KeyPattern.new('#.b.c')
 
-		assert_matches pattern, 'b.c'
-		assert_matches pattern, 'a.b.c'
-		assert_matches pattern, 'a.b.b.c'
-		refute_matches pattern, 'a.b.c.d'
-	end
+    assert_matches pattern, 'b.c'
+    assert_matches pattern, 'a.b.c'
+    assert_matches pattern, 'a.b.b.c'
+    refute_matches pattern, 'a.b.c.d'
+  end
 
-	def test_hash_in_the_middle
-		pattern = KeyPattern.new('a.#.c')
+  def test_hash_in_the_middle
+    pattern = KeyPattern.new('a.#.c')
 
-		assert_matches pattern, 'a.a.b.c'
-		assert_matches pattern, 'a.d.b.c'
-		refute_matches pattern, 'a.b.c.d'
-	end
+    assert_matches pattern, 'a.a.b.c'
+    assert_matches pattern, 'a.d.b.c'
+    refute_matches pattern, 'a.b.c.d'
+  end
 
-	def test_hash_at_the_end
-		pattern = KeyPattern.new('a.b.#')
+  def test_hash_at_the_end
+    pattern = KeyPattern.new('a.b.#')
 
-		assert_matches pattern, 'a.b.c.d'
-		assert_matches pattern, 'a.b.c'
-		assert_matches pattern, 'a.b.c.d.e'
-	end
+    assert_matches pattern, 'a.b.c.d'
+    assert_matches pattern, 'a.b.c'
+    assert_matches pattern, 'a.b.c.d.e'
+  end
 
-	def test_complex
-		pattern = KeyPattern.new('*.*.a.b.#.c.#')
+  def test_complex
+    pattern = KeyPattern.new('*.*.a.b.#.c.#')
 
-		assert_matches pattern, '1.2.a.b.c.d'
-		assert_matches pattern, '1.2.a.b.3.4.c.d'
-		assert_matches pattern, '1.2.a.b.c'
-		refute_matches pattern, 'a.b.c.d.e'
-	end
+    assert_matches pattern, '1.2.a.b.c.d'
+    assert_matches pattern, '1.2.a.b.3.4.c.d'
+    assert_matches pattern, '1.2.a.b.c'
+    refute_matches pattern, 'a.b.c.d.e'
+  end
 
-	def test_performance
-		pattern = KeyPattern.new('*.*.a.b.#.c.#')
+  def test_performance
+    pattern = KeyPattern.new('*.*.a.b.#.c.#')
 
-		n = 10_000
-		time = Benchmark.realtime { n.times { pattern =~ '1.2.a.b.3.4.c.d' } }
+    n = 10_000
+    time = Benchmark.realtime { n.times { pattern =~ '1.2.a.b.3.4.c.d' } }
 
-		assert time < 0.1
-	end
+    assert time < 0.1
+  end
 
-	protected
+  protected
 
-	def assert_matches(pattern, key)
-		assert pattern =~ key, "#{key} SHOULD match #{pattern}"
-	end
+  def assert_matches(pattern, key)
+    assert pattern =~ key, "#{key} SHOULD match #{pattern}"
+  end
 
-	def refute_matches(pattern, key)
-		assert pattern !~ key, "#{key} MUST NOT match #{pattern}"
-	end
+  def refute_matches(pattern, key)
+    assert pattern !~ key, "#{key} MUST NOT match #{pattern}"
+  end
 end

data/test/rabbit_connection_test.rb

@@ -1,151 +1,151 @@
-require_relative 'test_helper'
-require 'tochtli/test/test_case'
-
-class RabbitConnectionTest < Minitest::Test
-  def setup
-    Tochtli::RabbitConnection.close('test')
-  end
-
-  def teardown
-    Tochtli::RabbitConnection.close('test')
-  end
-
-  class TestMessage < Tochtli::Message
-    attributes :text
-  end
-
-  def test_connection_with_default_options
-    Tochtli::RabbitConnection.open('test') do |connection|
-      assert_equal "puzzleflow.services", connection.exchange.name
-    end
-  end
-
-  def test_connection_with_custom_options
-    Tochtli::RabbitConnection.open('test', exchange_name: "puzzleflow.tests") do |connection|
-      assert_equal "puzzleflow.tests", connection.exchange.name
-    end
-  end
-
-  def test_multiple_channels_and_exchanges
-    Tochtli::RabbitConnection.open('test', exchange_name: "puzzleflow.tests") do |connection|
-      another_thread = Thread.new {}
-
-      current_channel = connection.channel
-      another_channel = connection.channel(another_thread)
-
-      current_exchange = connection.exchange
-      another_exchange = connection.exchange(another_thread)
-
-      refute_equal current_channel, another_channel
-      refute_equal current_exchange, another_exchange
-      assert_equal "puzzleflow.tests", current_exchange.name
-      assert_equal "puzzleflow.tests", another_exchange.name
-    end
-  end
-
-  def test_queue_creation_and_existance
-    Tochtli::RabbitConnection.open('test') do |connection|
-      queue = connection.queue('test-queue', [], auto_delete: true)
-      refute_nil queue
-      assert_equal 'test-queue', queue.name
-      assert connection.queue_exists?('test-queue')
-    end
-  end
-
-  def test_reply_queue_recovery
-    Tochtli::RabbitConnection.open('test',
-                                   network_recovery_interval:     0.1,
-                                   recover_from_connection_close: true) do |rabbit_connection|
-      reply_queue   = rabbit_connection.reply_queue
-      original_name = reply_queue.name
-      timeout       = 0.3
-
-      message = TestMessage.new(text: "Response")
-      reply   = TestMessage.new(text: "Reply")
-      handler = Tochtli::Test::TestMessageHandler.new
-      reply_queue.register_message_handler message, handler, timeout
-
-      rabbit_connection.publish reply_queue.name, reply, correlation_id: message.id, timeout: timeout
-      sleep timeout
-
-      refute_nil handler.reply
-
-      # simulate network failure
-      rabbit_connection.connection.handle_network_failure(RuntimeError.new('fake connection error'))
-      sleep 0.1 until rabbit_connection.open? # wait for recovery
-      refute_equal original_name, reply_queue.name, "Recovered queue should have re-generated name"
-
-      message = TestMessage.new(text: "Response")
-      reply   = TestMessage.new(text: "Reply")
-      handler = Tochtli::Test::TestMessageHandler.new
-      reply_queue.register_message_handler message, handler, timeout
-
-      rabbit_connection.publish reply_queue.name, reply, correlation_id: message.id, timeout: timeout
-      sleep timeout
-
-      refute_nil handler.reply
-    end
-  end
-
-  def test_multithreaded_consumer_performance
-    work_pool_size = 10
-    Tochtli::RabbitConnection.open('test',
-                                   exchange_name:  "puzzleflow.tests",
-                                   work_pool_size: work_pool_size) do |connection|
-      mutex                  = Mutex.new
-      cv                     = ConditionVariable.new
-      thread_count           = 5
-      message_count          = 100
-      expected_message_count = message_count*thread_count
-
-      consumed         = 0
-      consumed_mutex   = Mutex.new
-      consumer_threads = Set.new
-      consumer         = Proc.new do |delivery_info, metadata, payload|
-        consumed_mutex.synchronize { consumed += 1 }
-        consumer_threads << Thread.current
-        connection.publish metadata.reply_to, TestMessage.new(text: "Response to #{payload}")
-      end
-
-      queue = connection.channel.queue('', auto_delete: true)
-      queue.bind(connection.exchange, routing_key: queue.name)
-      queue.subscribe(block: false, &consumer)
-
-      replies        = 0
-      reply_consumer = Proc.new do |delivery_info, metadata, payload|
-        replies += 1
-        mutex.synchronize { cv.signal } if replies == expected_message_count
-      end
-
-      reply_queue = connection.channel.queue('', auto_delete: true)
-      reply_queue.bind(connection.exchange, routing_key: reply_queue.name)
-      reply_queue.subscribe(block: false, &reply_consumer)
-
-      start_t = Time.now
-
-      threads = (1..thread_count).collect do
-        t                    = Thread.new do
-          message_count.times do |i|
-            connection.publish queue.name, TestMessage.new(text: "Message #{i}"),
-                               reply_to: reply_queue.name
-          end
-        end
-        t.abort_on_exception = true
-        t
-      end
-
-      threads.each(&:join)
-
-      mutex.synchronize { cv.wait(mutex, 5.0) }
-
-      end_t = Time.now
-      time  = end_t - start_t
-
-      assert_equal expected_message_count, consumed
-      assert_equal expected_message_count, replies
-      assert_equal work_pool_size, consumer_threads.size
-
-      puts "Published: #{expected_message_count} in #{time} (#{expected_message_count/time}req/s)"
-    end
-  end
-end
+require_relative 'test_helper'
+require 'tochtli/test/test_case'
+
+class RabbitConnectionTest < Minitest::Test
+  def setup
+    Tochtli::RabbitConnection.close('test')
+  end
+
+  def teardown
+    Tochtli::RabbitConnection.close('test')
+  end
+
+  class TestMessage < Tochtli::Message
+    attributes :text
+  end
+
+  def test_connection_with_default_options
+    Tochtli::RabbitConnection.open('test') do |connection|
+      assert_equal "puzzleflow.services", connection.exchange.name
+    end
+  end
+
+  def test_connection_with_custom_options
+    Tochtli::RabbitConnection.open('test', exchange_name: "puzzleflow.tests") do |connection|
+      assert_equal "puzzleflow.tests", connection.exchange.name
+    end
+  end
+
+  def test_multiple_channels_and_exchanges
+    Tochtli::RabbitConnection.open('test', exchange_name: "puzzleflow.tests") do |connection|
+      another_thread = Thread.new {}
+
+      current_channel = connection.channel
+      another_channel = connection.channel(another_thread)
+
+      current_exchange = connection.exchange
+      another_exchange = connection.exchange(another_thread)
+
+      refute_equal current_channel, another_channel
+      refute_equal current_exchange, another_exchange
+      assert_equal "puzzleflow.tests", current_exchange.name
+      assert_equal "puzzleflow.tests", another_exchange.name
+    end
+  end
+
+  def test_queue_creation_and_existance
+    Tochtli::RabbitConnection.open('test') do |connection|
+      queue = connection.queue('test-queue', [], auto_delete: true)
+      refute_nil queue
+      assert_equal 'test-queue', queue.name
+      assert connection.queue_exists?('test-queue')
+    end
+  end
+
+  def test_reply_queue_recovery
+    Tochtli::RabbitConnection.open('test',
+                                   network_recovery_interval:     0.1,
+                                   recover_from_connection_close: true) do |rabbit_connection|
+      reply_queue   = rabbit_connection.reply_queue
+      original_name = reply_queue.name
+      timeout       = 0.3
+
+      message = TestMessage.new(text: "Response")
+      reply   = TestMessage.new(text: "Reply")
+      handler = Tochtli::Test::TestMessageHandler.new
+      reply_queue.register_message_handler message, handler, timeout
+
+      rabbit_connection.publish reply_queue.name, reply, correlation_id: message.id, timeout: timeout
+      sleep timeout
+
+      refute_nil handler.reply
+
+      # simulate network failure
+      rabbit_connection.connection.handle_network_failure(RuntimeError.new('fake connection error'))
+      sleep 0.1 until rabbit_connection.open? # wait for recovery
+      refute_equal original_name, reply_queue.name, "Recovered queue should have re-generated name"
+
+      message = TestMessage.new(text: "Response")
+      reply   = TestMessage.new(text: "Reply")
+      handler = Tochtli::Test::TestMessageHandler.new
+      reply_queue.register_message_handler message, handler, timeout
+
+      rabbit_connection.publish reply_queue.name, reply, correlation_id: message.id, timeout: timeout
+      sleep timeout
+
+      refute_nil handler.reply
+    end
+  end
+
+  def test_multithreaded_consumer_performance
+    work_pool_size = 10
+    Tochtli::RabbitConnection.open('test',
+                                   exchange_name:  "puzzleflow.tests",
+                                   work_pool_size: work_pool_size) do |connection|
+      mutex                  = Mutex.new
+      cv                     = ConditionVariable.new
+      thread_count           = 5
+      message_count          = 100
+      expected_message_count = message_count*thread_count
+
+      consumed         = 0
+      consumed_mutex   = Mutex.new
+      consumer_threads = Set.new
+      consumer         = Proc.new do |delivery_info, metadata, payload|
+        consumed_mutex.synchronize { consumed += 1 }
+        consumer_threads << Thread.current
+        connection.publish metadata.reply_to, TestMessage.new(text: "Response to #{payload}")
+      end
+
+      queue = connection.channel.queue('', auto_delete: true)
+      queue.bind(connection.exchange, routing_key: queue.name)
+      queue.subscribe(block: false, &consumer)
+
+      replies        = 0
+      reply_consumer = Proc.new do |delivery_info, metadata, payload|
+        replies += 1
+        mutex.synchronize { cv.signal } if replies == expected_message_count
+      end
+
+      reply_queue = connection.channel.queue('', auto_delete: true)
+      reply_queue.bind(connection.exchange, routing_key: reply_queue.name)
+      reply_queue.subscribe(block: false, &reply_consumer)
+
+      start_t = Time.now
+
+      threads = (1..thread_count).collect do
+        t                    = Thread.new do
+          message_count.times do |i|
+            connection.publish queue.name, TestMessage.new(text: "Message #{i}"),
+                               reply_to: reply_queue.name
+          end
+        end
+        t.abort_on_exception = true
+        t
+      end
+
+      threads.each(&:join)
+
+      mutex.synchronize { cv.wait(mutex, 5.0) }
+
+      end_t = Time.now
+      time  = end_t - start_t
+
+      assert_equal expected_message_count, consumed
+      assert_equal expected_message_count, replies
+      assert_equal work_pool_size, consumer_threads.size
+
+      puts "Published: #{expected_message_count} in #{time} (#{expected_message_count/time}req/s)"
+    end
+  end
+end

data/test/version_test.rb

@@ -1,8 +1,8 @@
 require_relative 'test_helper'
 
 class VersionTest < Minitest::Test
-	def test_version_match
-		spec = Gem::Specification::load(File.expand_path('../../tochtli.gemspec', __FILE__))
-		assert_equal Tochtli::VERSION, spec.version.to_s, "Gem version mismatch. Run: 'rake gemspec'"
-	end
+  def test_version_match
+    spec = Gem::Specification::load(File.expand_path('../../tochtli.gemspec', __FILE__))
+    assert_equal Tochtli::VERSION, spec.version.to_s, "Gem version mismatch. Run: 'rake gemspec'"
+  end
 end

data/tochtli.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: tochtli 0.5.0 ruby lib
+# stub: tochtli 0.5.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "tochtli"
-  s.version = "0.5.0"
+  s.version = "0.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Rafal Bigaj"]
-  s.date = "2015-08-19"
+  s.date = "2015-08-20"
   s.description = "Lightweight framework for service oriented applications based on bunny (RabbitMQ)"
   s.email = "rafal.bigaj@puzzleflow.com"
   s.extra_rdoc_files = [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tochtli
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Rafal Bigaj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-19 00:00:00.000000000 Z
+date: 2015-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny