brown 1.1.2 → 2.1.0

data/lib/brown/queue_definition.rb

@@ -1,32 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-class Brown::QueueDefinition
-	attr_reader :options
-
-	def initialize(name, options)
-		@normalised_queue = "smith.#{name}"
-		@denormalised_queue = "#{name}"
-		@options = options
-	end
-
-	def denormalise
-		@denormalised_queue
-	end
-
-	def name
-		@normalised_queue
-	end
-
-	def normalise
-		@normalised_queue
-	end
-
-	# to_a is defined to make the splat operator work.
-	def to_a
-		return @normalised_queue, @options
-	end
-
-	def to_s
-		"<#{self.class}: #{@denormalised_queue}, #{@options.inspect}>"
-	end
-end

data/lib/brown/queue_factory.rb

@@ -1,33 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-class Brown::QueueFactory
-	def initialize
-		@cache = {}
-	end
-
-	# Convenience method that returns a Sender object.
-	def sender(queue_name, opts={}, &blk)
-		k = "sender:#{queue_name}"
-		@cache[k] ||= Brown::Sender.new(queue_name, opts)
-		blk.call(@cache[k])
-	end
-
-	# Convenience method that returns a Receiver object.
-	def receiver(queue_name, opts={}, &blk)
-		k = "receiver:#{queue_name}"
-		@cache[k] ||= Brown::Receiver.new(queue_name, opts)
-		blk.call(@cache[k])
-	end
-
-	# Passes each queue to the supplied block.
-	def each_queue
-		@cache.values.each do |queue|
-			yield queue if block_given?
-		end
-	end
-
-	# Returns all queues as a hash, with the queue name being the key.
-	def queues
-		@cache
-	end
-end

data/lib/brown/receiver.rb

@@ -1,143 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'brown/logger'
-require 'brown/util'
-
-class Brown::Receiver
-	include Brown::Logger
-	include Brown::Util
-
-	def initialize(queue_def, opts={}, &blk)
-		@queue_def = queue_def.is_a?(Brown::QueueDefinition) ? queue_def : Brown::QueueDefinition.new(queue_def, opts)
-
-		@acl_type_cache = Brown::ACLLookup
-
-		@options = opts
-
-		@requeue_options = {}
-		@requeue_queue   = Brown::Sender.new(@queue_def, opts)
-
-		@payload_type = Array(option_or_default(@queue_def.options, :type, []))
-
-		prefetch = option_or_default(@queue_def.options, :prefetch, 1)
-
-		@channel_completion = EM::Completion.new
-		@queue_completion = EM::Completion.new
-
-		open_channel(:prefetch => prefetch) do |channel|
-			logger.debug { "channel open for receiver on #{@queue_def.denormalise}" }
-			channel.on_error do |ch, close|
-				logger.fatal { "Channel error: #{close.inspect}" }
-			end
-
-			channel.queue(@queue_def.normalise) do |queue|
-				logger.debug { "Registered queue #{@queue_def.denormalise} on channel" }
-				@queue_completion.succeed(queue)
-			end
-
-			@channel_completion.succeed(channel)
-		end
-
-		blk.call(self) if blk
-	end
-
-	def ack(multiple=false)
-		@channel_completion.completion {|channel| channel.ack(multiple) }
-	end
-
-	# Subscribes to a queue and passes the headers and payload into the
-	# block. +subscribe+ will automatically acknowledge the message unless
-	# the options sets :ack to false.
-	def subscribe(opts = {}, &blk)
-		@queue_completion.completion do |queue|
-			logger.debug { "Subscribing to: [queue]:#{@queue_def.denormalise} [options]:#{@queue_def.options}" }
-			queue.subscribe(opts.merge(:ack => true)) do |metadata,payload|
-				logger.debug { "Received a message on #{@queue_def.denormalise}: #{metadata.to_hash.inspect}" }
-				if payload
-					on_message(metadata, payload, &blk)
-				else
-					logger.debug { "Received null message on: #{@queue_def.denormalise} [options]:#{@queue_def.options}" }
-				end
-			end
-		end
-	end
-
-	def unsubscribe(&blk)
-		@queue_completion.completion do |queue|
-			queue.unsubscribe(&blk)
-		end
-	end
-
-	def requeue_parameters(opts)
-		@requeue_options.merge!(opts)
-	end
-
-	def on_requeue(&blk)
-		@requeue_options[:on_requeue] = blk
-	end
-
-	def on_requeue_limit(&blk)
-		@requeue_options[:on_requeue_limit] = blk
-	end
-
-	# pops a message off the queue and passes the headers and payload
-	# into the block. +pop+ will automatically acknowledge the message
-	# unless the options sets :ack to false.
-	def pop(&blk)
-		@queue_completion.completion do |queue|
-			queue.pop({}) do |metadata, payload|
-				if payload
-					on_message(metadata, payload, &blk)
-				else
-					blk.call(nil,nil)
-				end
-			end
-		end
-	end
-
-	# Define a channel error handler.
-	def on_error(chain=false, &blk)
-		# TODO Check that this chains callbacks
-		@channel_completion.completion do |channel|
-			channel.on_error(&blk)
-		end
-	end
-
-	def queue_name
-		@queue_def.denormalise
-	end
-
-	def delete(&blk)
-		@queue_completion.completion do |queue|
-			@channel_completion.completion do |channel|
-				queue.unbind(exchange) do
-					queue.delete do
-						exchange.delete do
-							channel.close(&blk)
-						end
-					end
-				end
-			end
-		end
-	end
-
-	def status(&blk)
-		@queue_completion.completion do |queue|
-			queue.status do |num_messages, num_consumers|
-				blk.call(num_messages, num_consumers)
-			end
-		end
-	end
-
-	private
-
-	def on_message(metadata, payload, &blk)
-		if @payload_type.empty? || @payload_type.include?(@acl_type_cache.get_by_hash(metadata.type))
-			Brown::Message.new(payload, metadata, @requeue_queue, @requeue_options, @options, &blk)
-		else
-			allowable_acls = @payload_type.join(", ")
-			received_acl = @acl_type_cache.get_by_hash(metadata.type)
-			raise ACL::IncorrectTypeError, "Received ACL: #{received_acl} on queue: #{@queue_def.denormalise}. This queue can only accept the following ACLs: #{allowable_acls}"
-		end
-	end
-end

data/lib/brown/sender.rb

@@ -1,92 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'brown/logger'
-require 'brown/util'
-
-class Brown::Sender
-	include Brown::Logger
-	include Brown::Util
-
-	attr_reader :name
-
-	def initialize(queue_def, opts={})
-		@queue_def = queue_def.is_a?(Brown::QueueDefinition) ? queue_def : Brown::QueueDefinition.new(queue_def, opts)
-		@name      = @queue_def.denormalise
-
-		@reply_container = {}
-
-		@message_count = 0
-
-		@channel_completion = EM::Completion.new
-
-		open_channel do |channel|
-			logger.debug { "Opening a channel for sending" }
-			@channel_completion.succeed(channel)
-		end
-	end
-
-	def publish(payload, opts={}, &blk)
-		logger.debug { "Publishing to: [queue]: #{@queue_def.denormalise}. [options]: #{opts}" }
-		logger.debug { "ACL content: [queue]: #{@queue_def.denormalise}, [metadata type]: #{payload.class}, [message]: #{payload.inspect}" }
-
-		increment_counter
-
-		type = Brown::ACLLookup.get_by_type(payload.class)
-
-		@channel_completion.completion do |channel|
-			logger.debug { "Publishing #{payload.inspect} to queue #{@queue_def.denormalise}" }
-			AMQP::Exchange.default(channel).publish(payload.to_s, opts.merge(:type => type, :routing_key => @queue_def.normalise), &blk)
-		end
-	end
-
-	def delete(&blk)
-		queue.delete do
-			@channel_completion.completion do |channel|
-				channel.close(&blk)
-			end
-		end
-	end
-
-=begin
-	def status(&blk)
-		@queue_completion.completion do |queue|
-			queue.status do |num_messages, num_consumers|
-				blk.call(num_messages, num_consumers) if blk
-			end
-		end
-	end
-
-	def message_count(&blk)
-		status do |messages|
-			blk.call(messages) if blk
-		end
-	end
-
-	def consumer_count(&blk)
-		status do |_, consumers|
-			blk.call(consumers) if blk
-		end
-	end
-=end
-
-	def counter
-		@message_count
-	end
-
-	# Define a channel error handler.
-	def on_error(chain=false, &blk)
-		@channel_completion.completion do |channel|
-			channel.on_error(&blk)
-		end
-	end
-
-	def queue_name
-		@queue_def.denormalise
-	end
-
-	private
-
-	def increment_counter(value=1)
-		@message_count += value
-	end
-end

data/lib/brown/util.rb

@@ -1,58 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require "brown/amqp_errors"
-require "brown/logger"
-
-module Brown::Util
-	include Brown::AmqpErrors
-	include Brown::Logger
-
-	def number_of_messages
-		status do |num_messages, _|
-			yield num_messages
-		end
-	end
-
-	def number_of_consumers
-		status do |_, num_consumers|
-			yield num_consumers
-		end
-	end
-
-	private
-
-	def open_channel(opts={}, &blk)
-		AMQP::Channel.new(Brown.connection) do |channel,_|
-			logger.debug { "Opened channel: #{"%#x" % channel.object_id}" }
-
-			channel.auto_recovery = true
-			logger.debug { "Channel auto recovery enabled" }
-
-			# Set up QoS. If you do not do this then any subscribes will get
-			# overwhelmed if there are too many messages.
-			prefetch = opts[:prefetch] || 1
-
-			channel.prefetch(prefetch)
-			logger.debug { "AMQP prefetch set to: #{prefetch}" }
-
-			blk.call(channel)
-		end
-	end
-
-	def random(prefix = '', suffix = '')
-		"#{prefix}#{SecureRandom.hex(8)}#{suffix}"
-	end
-
-	def option_or_default(options, key, default, &blk)
-		if options.is_a?(Hash)
-			if options.key?(key)
-				v = options.delete(key)
-				(blk) ? blk.call(v) : v
-			else
-				default
-			end
-		else
-			raise ArguementError, "Options must be a Hash."
-		end
-	end
-end

data/lib/smith.rb

@@ -1,4 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'brown'
-
-Smith = Brown